const char **auth_methods = NULL;
switch (lp_server_role()) {
case ROLE_STANDALONE:
- auth_methods = lp_parm_string_list(-1, "auth methods", "standalone", NULL);
+ auth_methods = lp_parm_string_list(NULL, "auth methods", "standalone", NULL);
break;
case ROLE_DOMAIN_MEMBER:
- auth_methods = lp_parm_string_list(-1, "auth methods", "member server", NULL);
+ auth_methods = lp_parm_string_list(NULL, "auth methods", "member server", NULL);
break;
case ROLE_DOMAIN_CONTROLLER:
- auth_methods = lp_parm_string_list(-1, "auth methods", "domain controller", NULL);
+ auth_methods = lp_parm_string_list(NULL, "auth methods", "domain controller", NULL);
break;
}
return auth_context_create_methods(mem_ctx, auth_methods, ev, msg, auth_ctx);
_PUBLIC_ NTSTATUS auth_system_session_info(TALLOC_CTX *parent_ctx,
struct auth_session_info **_session_info)
{
- return _auth_system_session_info(parent_ctx, lp_parm_bool(-1,"system","anonymous", False),
- _session_info);
+ return _auth_system_session_info(parent_ctx,
+ lp_parm_bool(NULL, "system", "anonymous", false),
+ _session_info);
}
/*
_PUBLIC_ const char *gensec_get_target_hostname(struct gensec_security *gensec_security)
{
/* We allow the target hostname to be overriden for testing purposes */
- const char *target_hostname = lp_parm_string(-1, "gensec", "target_hostname");
+ const char *target_hostname = lp_parm_string(NULL, "gensec", "target_hostname");
if (target_hostname) {
return target_hostname;
}
*/
NTSTATUS gensec_register(const struct gensec_security_ops *ops)
{
- if (!lp_parm_bool(-1, "gensec", ops->name, ops->enabled)) {
+ if (!lp_parm_bool(NULL, "gensec", ops->name, ops->enabled)) {
DEBUG(2,("gensec subsystem %s is disabled\n", ops->name));
return NT_STATUS_OK;
}
gensec_gssapi_state->gss_exchange_count = 0;
gensec_gssapi_state->max_wrap_buf_size
- = lp_parm_int(-1, "gensec_gssapi", "max wrap buf size", 65536);
+ = lp_parm_int(NULL, "gensec_gssapi", "max wrap buf size", 65536);
gensec_gssapi_state->sasl = False;
gensec_gssapi_state->sasl_state = STAGE_GSS_NEG;
gensec_gssapi_state->input_chan_bindings = GSS_C_NO_CHANNEL_BINDINGS;
gensec_gssapi_state->want_flags = 0;
- if (lp_parm_bool(-1, "gensec_gssapi", "mutual", True)) {
+ if (lp_parm_bool(NULL, "gensec_gssapi", "mutual", true)) {
gensec_gssapi_state->want_flags |= GSS_C_MUTUAL_FLAG;
}
- if (lp_parm_bool(-1, "gensec_gssapi", "delegation", True)) {
+ if (lp_parm_bool(NULL, "gensec_gssapi", "delegation", true)) {
gensec_gssapi_state->want_flags |= GSS_C_DELEG_FLAG;
}
- if (lp_parm_bool(-1, "gensec_gssapi", "replay", True)) {
+ if (lp_parm_bool(NULL, "gensec_gssapi", "replay", true)) {
gensec_gssapi_state->want_flags |= GSS_C_REPLAY_FLAG;
}
- if (lp_parm_bool(-1, "gensec_gssapi", "sequence", True)) {
+ if (lp_parm_bool(NULL, "gensec_gssapi", "sequence", true)) {
gensec_gssapi_state->want_flags |= GSS_C_SEQUENCE_FLAG;
}
}
/* don't do DNS lookups of any kind, it might/will fail for a netbios name */
- ret = gsskrb5_set_dns_canonicalize(lp_parm_bool(-1, "krb5", "set_dns_canonicalize", false));
+ ret = gsskrb5_set_dns_canonicalize(lp_parm_bool(NULL, "krb5", "set_dns_canonicalize", false));
if (ret) {
DEBUG(1,("gensec_krb5_start: gsskrb5_set_dns_canonicalize failed\n"));
talloc_free(gensec_gssapi_state);
talloc_free(mem_ctx);
return nt_status;
}
- } else if (!lp_parm_bool(-1, "gensec", "require_pac", False)) {
+ } else if (!lp_parm_bool(NULL, "gensec", "require_pac", false)) {
DEBUG(1, ("Unable to find PAC, resorting to local user lookup: %s\n",
gssapi_error_string(mem_ctx, maj_stat, min_stat, gensec_gssapi_state->gss_oid)));
nt_status = sam_get_server_info_principal(mem_ctx, principal_string,
KRB5_AUTHDATA_WIN2K_PAC,
&pac_data);
- if (ret && lp_parm_bool(-1, "gensec", "require_pac", False)) {
+ if (ret && lp_parm_bool(NULL, "gensec", "require_pac", false)) {
DEBUG(1, ("Unable to find PAC in ticket from %s, failing to allow access: %s \n",
principal_string,
smb_get_krb5_error_message(context,
#include "auth/gensec/schannel.h"
#include "auth/credentials/credentials.h"
#include "auth/gensec/gensec.h"
+#include "auth/gensec/schannel_proto.h"
#define NETSEC_SIGN_SIGNATURE { 0x77, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 }
#define NETSEC_SEAL_SIGNATURE { 0x77, 0x00, 0x7a, 0x00, 0xff, 0xff, 0x00, 0x00 }
status = NT_STATUS_INVALID_PARAMETER;
switch (hi->proto) {
case KRB5_KRBHST_UDP:
- if (lp_parm_bool(-1, "krb5", "udp", True)) {
+ if (lp_parm_bool(NULL, "krb5", "udp", true)) {
status = socket_create(name, SOCKET_TYPE_DGRAM, &smb_krb5->sock, 0);
}
break;
case KRB5_KRBHST_TCP:
- if (lp_parm_bool(-1, "krb5", "tcp", True)) {
+ if (lp_parm_bool(NULL, "krb5", "tcp", true)) {
status = socket_create(name, SOCKET_TYPE_STREAM, &smb_krb5->sock, 0);
}
break;
/* Set options in kerberos */
krb5_set_dns_canonicalize_hostname((*smb_krb5_context)->krb5_context,
- lp_parm_bool(-1, "krb5", "set_dns_canonicalize", false));
+ lp_parm_bool(NULL, "krb5", "set_dns_canonicalize", false));
return 0;
}
gensec_ntlmssp_state->get_domain = lp_workgroup;
- gensec_ntlmssp_state->unicode = lp_parm_bool(-1, "ntlmssp_client", "unicode", True);
+ gensec_ntlmssp_state->unicode = lp_parm_bool(NULL, "ntlmssp_client", "unicode", true);
- gensec_ntlmssp_state->use_nt_response = lp_parm_bool(-1, "ntlmssp_client", "send_nt_reponse", True);
+ gensec_ntlmssp_state->use_nt_response = lp_parm_bool(NULL, "ntlmssp_client", "send_nt_reponse", true);
gensec_ntlmssp_state->allow_lm_key = (lp_client_lanman_auth()
- && (lp_parm_bool(-1, "ntlmssp_client", "allow_lm_key", False)
- || lp_parm_bool(-1, "ntlmssp_client", "lm_key", False)));
+ && (lp_parm_bool(NULL, "ntlmssp_client", "allow_lm_key", false)
+ || lp_parm_bool(NULL, "ntlmssp_client", "lm_key", false)));
gensec_ntlmssp_state->use_ntlmv2 = lp_client_ntlmv2_auth();
NTLMSSP_NEGOTIATE_NTLM |
NTLMSSP_REQUEST_TARGET;
- if (lp_parm_bool(-1, "ntlmssp_client", "128bit", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "128bit", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_128;
}
- if (lp_parm_bool(-1, "ntlmssp_client", "56bit", False)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "56bit", false)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_56;
}
- if (lp_parm_bool(-1, "ntlmssp_client", "lm_key", False)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "lm_key", false)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_LM_KEY;
}
- if (lp_parm_bool(-1, "ntlmssp_client", "keyexchange", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "keyexchange", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_KEY_EXCH;
}
- if (lp_parm_bool(-1, "ntlmssp_client", "alwayssign", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "alwayssign", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
}
- if (lp_parm_bool(-1, "ntlmssp_client", "ntlm2", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_client", "ntlm2", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_NTLM2;
} else {
/* apparently we can't do ntlmv2 if we don't do ntlm2 */
gensec_ntlmssp_state->expected_state = NTLMSSP_NEGOTIATE;
gensec_ntlmssp_state->allow_lm_key = (lp_lanman_auth()
- && lp_parm_bool(-1, "ntlmssp_server", "allow_lm_key", False));
+ && lp_parm_bool(NULL, "ntlmssp_server", "allow_lm_key", false));
gensec_ntlmssp_state->server_multiple_authentications = False;
gensec_ntlmssp_state->nt_resp = data_blob(NULL, 0);
gensec_ntlmssp_state->encrypted_session_key = data_blob(NULL, 0);
- if (lp_parm_bool(-1, "ntlmssp_server", "128bit", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_server", "128bit", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_128;
}
- if (lp_parm_bool(-1, "ntlmssp_server", "56bit", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_server", "56bit", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_56;
}
- if (lp_parm_bool(-1, "ntlmssp_server", "keyexchange", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_server", "keyexchange", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_KEY_EXCH;
}
- if (lp_parm_bool(-1, "ntlmssp_server", "alwayssign", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_server", "alwayssign", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
}
- if (lp_parm_bool(-1, "ntlmssp_server", "ntlm2", True)) {
+ if (lp_parm_bool(NULL, "ntlmssp_server", "ntlm2", true)) {
gensec_ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_NTLM2;
}
*/
};
-struct argdef * find_named_arg(const char * arg)
+static struct argdef * find_named_arg(const char * arg)
{
int i;
* could accumulate a remainder if ibs and obs don't match.
*/
iomax = 2 * MAX(ibs, obs);
- if ((iobuf = malloc(iomax)) == NULL) {
+ if ((iobuf = malloc_array_p(uint8_t, iomax)) == NULL) {
fprintf(stderr,
"%s: failed to allocate IO buffer of %llu bytes\n",
PROGNAME, (unsigned long long)iomax);
TALLOC_CTX *mem_ctx, const char *dbname,
int flags)
{
- const char *dir = lp_parm_string(-1, "ctdb", "shared data");
+ const char *dir = lp_parm_string(NULL, "ctdb", "shared data");
char *path;
struct tdb_wrap *w;
if (dir == NULL) {
struct cluster_state *state;
int ret;
- if (!lp_parm_bool(-1, "ctdb", "enable", False)) {
+ if (!lp_parm_bool(NULL, "ctdb", "enable", false)) {
return;
}
odb->ntvfs_ctx = ntvfs_ctx;
/* leave oplocks disabled by default until the code is working */
- odb->oplocks = lp_parm_bool(-1, "opendb", "oplocks", False);
+ odb->oplocks = lp_parm_bool(NULL, "opendb", "oplocks", false);
return odb;
}
return;
}
- periodic_startup_interval = lp_parm_int(-1, "dreplsrv", "periodic_startup_interval", 15); /* in seconds */
- service->periodic.interval = lp_parm_int(-1, "dreplsrv", "periodic_interval", 300); /* in seconds */
+ periodic_startup_interval = lp_parm_int(NULL, "dreplsrv", "periodic_startup_interval", 15); /* in seconds */
+ service->periodic.interval = lp_parm_int(NULL, "dreplsrv", "periodic_interval", 300); /* in seconds */
status = dreplsrv_periodic_schedule(service, periodic_startup_interval);
if (!W_ERROR_IS_OK(status)) {
struct smb_krb5_context *smb_krb5_context;
ret = smb_krb5_init_context(mem_ctx,
- ldb_get_opaque(sam_ctx, "EventContext"),
+ (struct event_context *)ldb_get_opaque(sam_ctx, "EventContext"),
&smb_krb5_context);
if (ret) {
return LDB_ERR_OPERATIONS_ERROR;
}
- if (lp_parm_bool(-1, "password_hash", "create_aes_key", false)) {
+ if (lp_parm_bool(NULL, "password_hash", "create_aes_key", false)) {
/*
* TODO:
*
entry_ex->entry.flags.ok_as_delegate = 1;
}
- if (lp_parm_bool(-1, "kdc", "require spn for service", True)) {
+ if (lp_parm_bool(NULL, "kdc", "require spn for service", true)) {
if (!is_computer && !ldb_msg_find_attr_as_string(msg, "servicePrincipalName", NULL)) {
entry_ex->entry.flags.server = 0;
}
MprVar *np;
Ejs *ep;
- ep = mprMalloc(sizeof(Ejs));
+ ep = (Ejs *)mprMalloc(sizeof(Ejs));
if (ep == 0) {
return (EjsId) -1;
}
bool charset_register_backend(const void *_funcs)
{
- struct charset_functions *funcs = memdup(_funcs,sizeof(struct charset_functions));
+ struct charset_functions *funcs = (struct charset_functions *)memdup(_funcs,sizeof(struct charset_functions));
struct charset_functions *c;
/* Check whether we already have this charset... */
}
#ifdef HAVE_NATIVE_ICONV
- if ((!from || !to) && !lp_parm_bool(-1, "iconv", "native", true)) {
+ if ((!from || !to) && !lp_parm_bool(NULL, "iconv", "native", true)) {
goto failed;
}
if (!from) {
}
/* allow admins to force non-sync ldb for all databases */
- if (lp_parm_bool(-1, "ldb", "nosync", False)) {
+ if (lp_parm_bool(NULL, "ldb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
*/
struct db_context *db_tmp_open(TALLOC_CTX *mem_ctx, const char *name, int tdb_flags)
{
- if (lp_parm_bool(-1, "ctdb", "enable", False) &&
- lp_parm_bool(-1, "ctdb", name, True)) {
+ if (lp_parm_bool(NULL, "ctdb", "enable", false) &&
+ lp_parm_bool(NULL, "ctdb", name, true)) {
return db_tmp_open_ctdb(mem_ctx, name, tdb_flags);
}
#if _SAMBA_BUILD_
if (name == NULL) {
- name = lp_parm_string(-1, "event", "backend");
+ name = lp_parm_string(NULL, "event", "backend");
}
#endif
if (name == NULL) {
}
}
- target_str = lp_parm_string(-1, "convert", "target");
+ target_str = lp_parm_string(NULL, "convert", "target");
if (!target_str || strcasecmp(target_str, "openldap") == 0) {
target = TARGET_OPENLDAP;
const char **tempdir);
static bool test_del_nonexistant_key(struct torture_context *tctx,
- const void *test_data)
+ const void *test_data)
{
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
WERROR error = hive_key_del(root, "bla");
torture_assert_werr_equal(tctx, error, WERR_NOT_FOUND,
"invalid return code");
const void *test_data)
{
uint32_t num_subkeys, num_values;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
WERROR error;
/* This is a new backend. There should be no subkeys and no
const void *test_data)
{
uint32_t num_subkeys, num_values;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
WERROR error;
struct hive_key *subkey;
uint32_t data = 42;
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
error = hive_key_add_name(mem_ctx, root, "Nested Key", NULL,
}
static bool test_flush_key(struct torture_context *tctx,
- const void *test_data)
+ const void *test_data)
{
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
torture_assert_werr_ok(tctx, hive_key_flush(root), "flush key");
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
error = hive_key_add_name(mem_ctx, root, "Nested Key", NULL,
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
uint32_t data = 42;
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
uint32_t data = 42;
uint32_t type;
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
uint32_t data = 42;
uint32_t type;
{
WERROR error;
struct hive_key *subkey;
- const struct hive_key *root = test_data;
+ const struct hive_key *root = (const struct hive_key *)test_data;
TALLOC_CTX *mem_ctx = tctx;
uint32_t data = 42;
uint32_t type;
static bool test_get_predefined(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root;
WERROR error;
static bool test_predef_key_by_name(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root;
WERROR error;
static bool test_predef_key_by_name_invalid(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root;
WERROR error;
static bool test_create_subkey(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *newkey;
WERROR error;
static bool test_create_nested_subkey(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *newkey1, *newkey2;
WERROR error;
static bool test_key_add_abs_top(struct torture_context *tctx,
const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root;
WERROR error;
const void *_data)
{
WERROR error;
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *result1, *result2;
error = reg_key_add_abs(tctx, rctx, "HKEY_CLASSES_ROOT\\bloe", 0, NULL, &result1);
static bool test_del_key(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *newkey;
WERROR error;
static bool test_flush_key(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *subkey;
WERROR error;
static bool test_query_key(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *subkey;
WERROR error;
NTTIME last_changed_time;
static bool test_query_key_nums(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *root, *subkey1, *subkey2;
WERROR error;
uint32_t num_subkeys, num_values;
*/
static bool test_list_subkeys(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
NTTIME last_mod_time;
*/
static bool test_set_value(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
uint32_t data = 42;
*/
static bool test_security(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
struct security_descriptor *osd, *nsd;
*/
static bool test_get_value(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
DATA_BLOB data;
*/
static bool test_del_value(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
DATA_BLOB data;
*/
static bool test_list_values(struct torture_context *tctx, const void *_data)
{
- const struct registry_context *rctx = _data;
+ const struct registry_context *rctx =
+ (const struct registry_context *)_data;
struct registry_key *subkey = NULL, *root;
WERROR error;
DATA_BLOB data;
if (!(flags & SOCKET_FLAG_BLOCK) &&
type == SOCKET_TYPE_STREAM &&
- lp_parm_bool(-1, "socket", "testnonblock", False)) {
+ lp_parm_bool(NULL, "socket", "testnonblock", false)) {
(*new_sock)->flags |= SOCKET_FLAG_TESTNONBLOCK;
}
}
#else
- void tls_cert_dummy(void) {}
+void tls_cert_dummy(void) {}
#endif
static bool test_lists_shell(struct torture_context *tctx,
const void *test_data)
{
- const char *data = test_data;
+ const char *data = (const char *)test_data;
const char **ret1, **ret2, *tmp;
bool match = true;
TALLOC_CTX *mem_ctx = tctx;
req->received_wack = True;
/* although there can be a timeout in the packet, w2k3 screws it up,
so better to set it ourselves */
- req->timeout = lp_parm_int(-1, "nbt", "wack_timeout", 30);
+ req->timeout = lp_parm_int(NULL, "nbt", "wack_timeout", 30);
req->te = event_add_timed(req->nbtsock->event_ctx, req,
timeval_current_ofs(req->timeout, 0),
nbt_name_socket_timeout, req);
state->io_queries[i].in.broadcast = broadcast;
state->io_queries[i].in.wins_lookup = wins_lookup;
- state->io_queries[i].in.timeout = lp_parm_int(-1, "nbt", "timeout", 1);
+ state->io_queries[i].in.timeout = lp_parm_int(NULL, "nbt", "timeout", 1);
state->io_queries[i].in.retries = 2;
state->queries[i] = nbt_name_query_send(state->nbtsock, &state->io_queries[i]);
size = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
blob.data, blob.length, &vstr);
data_blob_free(&blob);
- (*str) = vstr;
+ (*str) = (char *)vstr;
if (size == -1) {
return NT_STATUS_ILLEGAL_CHARACTER;
}
drsuapi->s = s;
if (!drsuapi->binding) {
- if (lp_parm_bool(-1, "become_dc", "print", False)) {
+ if (lp_parm_bool(NULL, "become_dc", "print", false)) {
binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[krb5,print,seal]", s->source_dsa.dns_name);
if (composite_nomem(binding_str, c)) return;
} else {
char **error_string)
{
NTSTATUS nt_status = NT_STATUS_OK;
- struct samdump_state *samdump_state = private;
+ struct samdump_state *samdump_state = (struct samdump_state *)private;
*error_string = NULL;
switch (delta->delta_type) {
r2.out.error_string = NULL;
r2.in.binding_string = r->in.binding_string;
- r2.in.rid_crypt = lp_parm_bool(-1, "vampire", "rid decrypt", True);
+ r2.in.rid_crypt = lp_parm_bool(NULL, "vampire", "rid decrypt", true);
r2.in.init_fn = NULL;
r2.in.delta_fn = libnet_samdump_fn;
r2.in.fn_ctx = samdump_state;
#include "includes.h"
#include "lib/compression/mszip.h"
#include "librpc/ndr/libndr.h"
+#include "librpc/ndr/ndr_compression.h"
static NTSTATUS ndr_pull_compression_mszip_chunk(struct ndr_pull *ndrpull,
struct ndr_push *ndrpush,
packet->answers[0].rr_class = NBT_QCLASS_IP;
packet->answers[0].ttl = ttl;
packet->answers[0].rdata.data.length = 2;
- packet->answers[0].rdata.data.data = talloc_size(packet, 2);
+ packet->answers[0].rdata.data.data = talloc_array(packet, uint8_t, 2);
if (packet->answers[0].rdata.data.data == NULL) goto failed;
RSSVAL(packet->answers[0].rdata.data.data, 0, request_packet->operation);
static void nbtd_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
- uint32_t max_refresh_time = lp_parm_int(-1, "nbtd", "max_refresh_time", 7200);
+ uint32_t max_refresh_time = lp_parm_int(NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
iname->name.scope = NULL;
}
iname->nb_flags = nb_flags;
- iname->ttl = lp_parm_int(-1, "nbtd", "bcast_ttl", 300000);
+ iname->ttl = lp_parm_int(NULL, "nbtd", "bcast_ttl", 300000);
iname->registration_time = timeval_zero();
iname->wins_server = NULL;
ctx->private_data = NULL;
- owner = lp_parm_string(-1, "winsdb", "local_owner");
+ owner = lp_parm_string(NULL, "winsdb", "local_owner");
if (!owner) {
owner = iface_n_ip(0);
if (!owner) {
static void nbtd_wins_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
- uint32_t max_refresh_time = lp_parm_int(-1, "nbtd", "max_refresh_time", 7200);
+ uint32_t max_refresh_time = lp_parm_int(NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
/* none of the WINS servers responded - try again
periodically */
- int wins_retry_time = lp_parm_int(-1, "nbtd", "wins_retry", 300);
+ int wins_retry_time = lp_parm_int(NULL, "nbtd", "wins_retry", 300);
event_add_timed(iname->iface->nbtsrv->task->event_ctx,
iname,
timeval_current_ofs(wins_retry_time, 0),
talloc_free(h->ldb);
h->ldb = NULL;
- if (lp_parm_bool(-1,"winsdb", "nosync", False)) {
+ if (lp_parm_bool(NULL,"winsdb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
h = talloc(mem_ctx, struct winsdb_handle);
if (!h) return NULL;
- if (lp_parm_bool(-1,"winsdb", "nosync", False)) {
+ if (lp_parm_bool(NULL,"winsdb", "nosync", false)) {
flags |= LDB_FLG_NOSYNC;
}
h->caller = caller;
- owner = lp_parm_string(-1, "winsdb", "local_owner");
+ owner = lp_parm_string(NULL, "winsdb", "local_owner");
if (!owner) {
owner = iface_n_ip(0);
}
ldb_qsort(addresses, num_addrs , sizeof(addresses[0]),
src, (ldb_qsort_cmp_fn_t)nbtd_wins_randomize1Clist_sort);
- mask = lp_parm_string(-1, "nbtd", "wins_randomize1Clist_mask");
+ mask = lp_parm_string(NULL, "nbtd", "wins_randomize1Clist_mask");
if (!mask) {
mask = "255.255.255.0";
}
* Typ: Daten REG_DWORD
* Value: 0 = deactivated, 1 = activated
*/
- if (name->type == NBT_NAME_LOGON && lp_parm_bool(-1, "nbtd", "wins_prepend1Bto1Cqueries", True)) {
+ if (name->type == NBT_NAME_LOGON &&
+ lp_parm_bool(NULL, "nbtd", "wins_prepend1Bto1Cqueries", true)) {
struct nbt_name name_1b;
name_1b = *name;
* Typ: Daten REG_DWORD
* Value: 0 = deactivated, 1 = activated
*/
- if (name->type == NBT_NAME_LOGON && lp_parm_bool(-1, "nbtd", "wins_randomize1Clist", False)) {
+ if (name->type == NBT_NAME_LOGON &&
+ lp_parm_bool(NULL, "nbtd", "wins_randomize1Clist", false)) {
nbtd_wins_randomize1Clist(addresses, src);
}
nbtsrv->winssrv->config.max_renew_interval = lp_max_wins_ttl();
nbtsrv->winssrv->config.min_renew_interval = lp_min_wins_ttl();
- tmp = lp_parm_int(-1,"wreplsrv","tombstone_interval", 6*24*60*60);
+ tmp = lp_parm_int(NULL, "wreplsrv", "tombstone_interval", 6*24*60*60);
nbtsrv->winssrv->config.tombstone_interval = tmp;
- tmp = lp_parm_int(-1,"wreplsrv","tombstone_timeout", 1*24*60*60);
+ tmp = lp_parm_int(NULL, "wreplsrv"," tombstone_timeout", 1*24*60*60);
nbtsrv->winssrv->config.tombstone_timeout = tmp;
nbtsrv->winssrv->wins_db = winsdb_connect(nbtsrv->winssrv, WINSDB_HANDLE_CALLER_NBTD);
struct ntvfs_context *ntvfs_ctx)
{
if (ops == NULL) {
- if (lp_parm_bool(-1, "ctdb", "opendb", False)) {
+ if (lp_parm_bool(NULL, "ctdb", "opendb", false)) {
odb_ctdb_init_ops();
} else {
odb_tdb_init_ops();
odb->ntvfs_ctx = ntvfs_ctx;
/* leave oplocks disabled by default until the code is working */
- odb->oplocks = lp_parm_bool(-1, "opendb", "oplocks", False);
+ odb->oplocks = lp_parm_bool(NULL, "opendb", "oplocks", false);
return odb;
}
}
/* by default have a max of 512 entries in the cache. */
- ctx->cache_size = lp_parm_int(-1, "mangle", "cachesize", 512);
+ ctx->cache_size = lp_parm_int(NULL, "mangle", "cachesize", 512);
ctx->prefix_cache = talloc_array(ctx, char *, ctx->cache_size);
if (ctx->prefix_cache == NULL) {
memset(ctx->prefix_cache, 0, sizeof(char *) * ctx->cache_size);
memset(ctx->prefix_cache_hashes, 0, sizeof(uint32_t) * ctx->cache_size);
- ctx->mangle_prefix = lp_parm_int(-1, "mangle", "prefix", -1);
+ ctx->mangle_prefix = lp_parm_int(NULL, "mangle", "prefix", -1);
if (ctx->mangle_prefix < 0 || ctx->mangle_prefix > 6) {
ctx->mangle_prefix = DEFAULT_MANGLE_PREFIX;
}
{
struct inotify_private *in;
- if (!lp_parm_bool(-1, "notify", "inotify", True)) {
+ if (!lp_parm_bool(NULL, "notify", "inotify", true)) {
return NT_STATUS_INVALID_SYSTEM_SERVICE;
}
int fn_name(void) {return(*(int *)(ptr));}
#define FN_LOCAL_STRING(fn_name,val) \
- const char *fn_name(int i) {return(lp_string((LP_SNUM_OK(i) && loadparm.ServicePtrs[(i)]->val) ? loadparm.ServicePtrs[(i)]->val : sDefault.val));}
+ const char *fn_name(struct service *service) {return(lp_string((const char *)((service != NULL && service->val != NULL) ? service->val : sDefault.val)));}
#define FN_LOCAL_CONST_STRING(fn_name,val) \
- const char *fn_name(int i) {return (const char *)((LP_SNUM_OK(i) && loadparm.ServicePtrs[(i)]->val) ? loadparm.ServicePtrs[(i)]->val : sDefault.val);}
+ const char *fn_name(struct service *service) {return (const char *)(service != NULL && service->val != NULL) ? service->val : sDefault.val;}
#define FN_LOCAL_LIST(fn_name,val) \
- const char **fn_name(int i) {return(const char **)(LP_SNUM_OK(i)? loadparm.ServicePtrs[(i)]->val : sDefault.val);}
+ const char **fn_name(struct service *service) {return(const char **)(service != NULL && service->val != NULL? service->val : sDefault.val);}
#define FN_LOCAL_BOOL(fn_name,val) \
- bool fn_name(int i) {return(LP_SNUM_OK(i)? loadparm.ServicePtrs[(i)]->val : sDefault.val);}
-#if 0 /* unused */
-#define FN_LOCAL_CHAR(fn_name,val) \
- char fn_name(int i) {return(LP_SNUM_OK(i)? ServicePtrs[(i)]->val : sDefault.val);}
-#endif
+ bool fn_name(struct service *service) {return((service != NULL)? service->val : sDefault.val);}
#define FN_LOCAL_INTEGER(fn_name,val) \
- int fn_name(int i) {return(LP_SNUM_OK(i)? loadparm.ServicePtrs[(i)]->val : sDefault.val);}
+ int fn_name(struct service *service) {return((service != NULL)? service->val : sDefault.val);}
_PUBLIC_ FN_GLOBAL_INTEGER(lp_server_role, &loadparm.Globals.server_role)
_PUBLIC_ FN_GLOBAL_LIST(lp_smb_ports, &loadparm.Globals.smb_ports)
/* This is a helper function for parametrical options support. */
/* It returns a pointer to parametrical option value if it exists or NULL otherwise */
/* Actual parametrical functions are quite simple */
-const char *lp_get_parametric(int lookup_service, const char *type, const char *option)
+const char *lp_get_parametric(struct service *service, const char *type, const char *option)
{
char *vfskey;
struct param_opt *data;
- if (lookup_service >= 0 && !LP_SNUM_OK(lookup_service))
- return NULL;
-
- data = (lookup_service < 0) ?
- loadparm.Globals.param_opt : loadparm.ServicePtrs[lookup_service]->param_opt;
+ data = (service == NULL ? loadparm.Globals.param_opt : service->param_opt);
asprintf(&vfskey, "%s:%s", type, option);
strlower(vfskey);
data = data->next;
}
- if (lookup_service >= 0) {
+ if (service != NULL) {
/* Try to fetch the same option but from globals */
/* but only if we are not already working with Globals */
for (data = loadparm.Globals.param_opt; data;
/* Parametric option has following syntax: 'Type: option = value' */
/* Returned value is allocated in 'lp_talloc' context */
-const char *lp_parm_string(int lookup_service, const char *type, const char *option)
+const char *lp_parm_string(struct service *service, const char *type,
+ const char *option)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return lp_string(value);
/* Parametric option has following syntax: 'Type: option = value' */
/* Returned value is allocated in 'lp_talloc' context */
-const char **lp_parm_string_list(int lookup_service, const char *type, const char *option,
- const char *separator)
+const char **lp_parm_string_list(struct service *service, const char *type,
+ const char *option, const char *separator)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return str_list_make(talloc_autofree_context(), value, separator);
/* Return parametric option from a given service. Type is a part of option before ':' */
/* Parametric option has following syntax: 'Type: option = value' */
-int lp_parm_int(int lookup_service, const char *type, const char *option, int default_v)
+int lp_parm_int(struct service *service, const char *type, const char *option,
+ int default_v)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return lp_int(value);
* Parametric option has following syntax: 'Type: option = value'.
*/
-int lp_parm_bytes(int lookup_service, const char *type, const char *option, int default_v)
+int lp_parm_bytes(struct service *service, const char *type,
+ const char *option, int default_v)
{
uint64_t bval;
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value && conv_str_size(value, &bval)) {
if (bval <= INT_MAX) {
/* Return parametric option from a given service. Type is a part of option before ':' */
/* Parametric option has following syntax: 'Type: option = value' */
-unsigned long lp_parm_ulong(int lookup_service, const char *type, const char *option, unsigned long default_v)
+unsigned long lp_parm_ulong(struct service *service, const char *type,
+ const char *option, unsigned long default_v)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return lp_ulong(value);
}
-double lp_parm_double(int lookup_service, const char *type, const char *option, double default_v)
+double lp_parm_double(struct service *service, const char *type,
+ const char *option, double default_v)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return lp_double(value);
/* Return parametric option from a given service. Type is a part of option before ':' */
/* Parametric option has following syntax: 'Type: option = value' */
-bool lp_parm_bool(int lookup_service, const char *type, const char *option,
- bool default_v)
+bool lp_parm_bool(struct service *service, const char *type,
+ const char *option, bool default_v)
{
- const char *value = lp_get_parametric(lookup_service, type, option);
+ const char *value = lp_get_parametric(service, type, option);
if (value)
return lp_bool(value);
from service ifrom.
***************************************************************************/
-bool lp_add_home(const char *pszHomename, int iDefaultService,
+bool lp_add_home(const char *pszHomename, struct service *default_service,
const char *user, const char *pszHomedir)
{
struct service *service;
pstring newHomedir;
- service = add_a_service(loadparm.ServicePtrs[iDefaultService], pszHomename);
+ service = add_a_service(default_service, pszHomename);
if (service == NULL)
return false;
- if (!(*(loadparm.ServicePtrs[iDefaultService]->szPath))
- || strequal(loadparm.ServicePtrs[iDefaultService]->szPath, lp_pathname(-1))) {
+ if (!(*(default_service->szPath))
+ || strequal(default_service->szPath, sDefault.szPath)) {
pstrcpy(newHomedir, pszHomedir);
} else {
- pstrcpy(newHomedir, lp_pathname(iDefaultService));
+ pstrcpy(newHomedir, lp_pathname(default_service));
string_sub(newHomedir,"%H", pszHomedir, sizeof(newHomedir));
}
if (!(*(service->comment))) {
service->comment = talloc_asprintf(service, "Home directory of %s", user);
}
- service->bAvailable = sDefault.bAvailable;
- service->bBrowseable = sDefault.bBrowseable;
+ service->bAvailable = default_service->bAvailable;
+ service->bBrowseable = default_service->bBrowseable;
DEBUG(3, ("adding home's share [%s] for user '%s' at '%s'\n",
pszHomename, user, newHomedir));
Add a new service, based on an old one.
***************************************************************************/
-struct service *lp_add_service(const char *pszService, int iDefaultService)
+struct service *lp_add_service(const char *pszService,
+ struct service *default_service)
{
- return add_a_service(loadparm.ServicePtrs[iDefaultService], pszService);
+ return add_a_service(default_service, pszService);
}
/***************************************************************************
Add a new printer service, with defaults coming from service iFrom.
***************************************************************************/
-bool lp_add_printer(const char *pszPrintername, int iDefaultService)
+bool lp_add_printer(const char *pszPrintername, struct service *default_service)
{
const char *comment = "From Printcap";
struct service *service;
- service = add_a_service(loadparm.ServicePtrs[iDefaultService],
- pszPrintername);
+ service = add_a_service(default_service, pszPrintername);
if (service == NULL)
return false;
/*
return the parameter pointer for a parameter
*/
-void *lp_parm_ptr(int snum, struct parm_struct *parm)
+void *lp_parm_ptr(struct service *service, struct parm_struct *parm)
{
- if (snum == -1) {
+ if (service == NULL)
return parm->ptr;
- }
- return ((char *)loadparm.ServicePtrs[snum]) + PTR_DIFF(parm->ptr, &sDefault);
+
+ return ((char *)service) + PTR_DIFF(parm->ptr, &sDefault);
}
/***************************************************************************
return bRetval;
}
-/***************************************************************************
- Reset the max number of services.
-***************************************************************************/
-
-void lp_resetnumservices(void)
-{
- loadparm.iNumServices = 0;
-}
-
/***************************************************************************
Return the max number of services.
***************************************************************************/
dump_a_service(&sDefault, f);
for (iService = 0; iService < maxtoprint; iService++)
- lp_dump_one(f, show_defaults, iService);
+ lp_dump_one(f, show_defaults, loadparm.ServicePtrs[iService]);
}
/***************************************************************************
Display the contents of one service in human-readable form.
***************************************************************************/
-void lp_dump_one(FILE *f, bool show_defaults, int snum)
+void lp_dump_one(FILE *f, bool show_defaults, struct service *service)
{
- if (VALID(snum)) {
- if (loadparm.ServicePtrs[snum]->szService[0] == '\0')
+ if (service != NULL) {
+ if (service->szService[0] == '\0')
return;
- dump_a_service(loadparm.ServicePtrs[snum], f);
+ dump_a_service(service, f);
}
}
+struct service *lp_servicebynum(int snum)
+{
+ return loadparm.ServicePtrs[snum];
+}
+
+struct service *lp_service(const char *service_name)
+{
+ int snum = lp_servicenumber(service_name);
+ if (snum < 0)
+ return NULL;
+ return loadparm.ServicePtrs[snum];
+}
+
/***************************************************************************
Return the number of the service with the given name, or -1 if it doesn't
exist. Note that this is a DIFFERENT ANIMAL from the internal function
/*******************************************************************
A useful volume label function.
********************************************************************/
-const char *volume_label(int snum)
+const char *volume_label(struct service *service)
{
- const char *ret = lp_volume(snum);
+ const char *ret = lp_volume(service);
if (!*ret)
- return lp_servicename(snum);
+ return lp_servicename(service);
return ret;
}
loadparm.ServicePtrs[snum] = NULL;
}
-const char *lp_printername(int snum)
+const char *lp_printername(struct service *service)
{
- const char *ret = _lp_printername(snum);
+ const char *ret = _lp_printername(service);
if (ret == NULL || (ret != NULL && *ret == '\0'))
- ret = lp_const_servicename(snum);
+ ret = lp_const_servicename(service);
return ret;
}
ANNOUNCE_AS_NT_WORKSTATION=4
};
-
+struct service;
#include "param/proto.h"
#include "param/share.h"
#include "param/param.h"
-struct sclassic_snum {
- int snum;
+struct service {
+ struct service *service;
};
static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, struct share_context **ctx)
static const char *sclassic_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
{
- struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum);
+ struct service *s = talloc_get_type(scfg->opaque, struct service);
char *parm, *val;
const char *ret;
*val = '\0';
val++;
- ret = lp_parm_string(s->snum, parm, val);
+ ret = lp_parm_string(s, parm, val);
if (!ret) {
ret = defval;
}
}
if (strcmp(opt_name, SHARE_PATH) == 0) {
- return lp_pathname(s->snum);
+ return lp_pathname(s);
}
if (strcmp(opt_name, SHARE_COMMENT) == 0) {
- return lp_comment(s->snum);
+ return lp_comment(s);
}
if (strcmp(opt_name, SHARE_VOLUME) == 0) {
- return volume_label(s->snum);
+ return volume_label(s);
}
if (strcmp(opt_name, SHARE_TYPE) == 0) {
- if (lp_print_ok(s->snum)) {
+ if (lp_print_ok(s)) {
return "PRINTER";
}
- if (strcmp("NTFS", lp_fstype(s->snum)) == 0) {
+ if (strcmp("NTFS", lp_fstype(s)) == 0) {
return "DISK";
}
- return lp_fstype(s->snum);
+ return lp_fstype(s);
}
if (strcmp(opt_name, SHARE_PASSWORD) == 0) {
return defval;
}
-int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval)
+static int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval)
{
- struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum);
+ struct service *s = talloc_get_type(scfg->opaque, struct service);
char *parm, *val;
int ret;
*val = '\0';
val++;
- ret = lp_parm_int(s->snum, parm, val, defval);
+ ret = lp_parm_int(s, parm, val, defval);
if (!ret) {
ret = defval;
}
}
if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) {
- return lp_csc_policy(s->snum);
+ return lp_csc_policy(s);
}
if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) {
- return lp_max_connections(s->snum);
+ return lp_max_connections(s);
}
if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) {
- return lp_create_mask(s->snum);
+ return lp_create_mask(s);
}
if (strcmp(opt_name, SHARE_DIR_MASK) == 0) {
- return lp_dir_mask(s->snum);
+ return lp_dir_mask(s);
}
if (strcmp(opt_name, SHARE_FORCE_DIR_MODE) == 0) {
- return lp_force_dir_mode(s->snum);
+ return lp_force_dir_mode(s);
}
if (strcmp(opt_name, SHARE_FORCE_CREATE_MODE) == 0) {
- return lp_force_create_mode(s->snum);
+ return lp_force_create_mode(s);
}
return defval;
}
-BOOL sclassic_bool_option(struct share_config *scfg, const char *opt_name, BOOL defval)
+static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name,
+ bool defval)
{
- struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum);
+ struct service *s = talloc_get_type(scfg->opaque, struct service);
char *parm, *val;
BOOL ret;
*val = '\0';
val++;
- ret = lp_parm_bool(s->snum, parm, val, defval);
+ ret = lp_parm_bool(s, parm, val, defval);
talloc_free(parm);
return ret;
}
if (strcmp(opt_name, SHARE_AVAILABLE) == 0) {
- return lp_snum_ok(s->snum);
+ return s != NULL;
}
if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) {
- return lp_browseable(s->snum);
+ return lp_browseable(s);
}
if (strcmp(opt_name, SHARE_READONLY) == 0) {
- return lp_readonly(s->snum);
+ return lp_readonly(s);
}
if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) {
- return lp_map_system(s->snum);
+ return lp_map_system(s);
}
if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) {
- return lp_map_hidden(s->snum);
+ return lp_map_hidden(s);
}
if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) {
- return lp_map_archive(s->snum);
+ return lp_map_archive(s);
}
if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) {
- return lp_strict_locking(s->snum);
+ return lp_strict_locking(s);
}
if (strcmp(opt_name, SHARE_STRICT_SYNC) == 0) {
- return lp_strict_sync(s->snum);
+ return lp_strict_sync(s);
}
if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) {
- return lp_msdfs_root(s->snum);
+ return lp_msdfs_root(s);
}
if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) {
- return lp_ci_filesystem(s->snum);
+ return lp_ci_filesystem(s);
}
DEBUG(0,("request for unknown share bool option '%s'\n",
return defval;
}
-const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
+static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
{
- struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum);
+ struct service *s = talloc_get_type(scfg->opaque, struct service);
char *parm, *val;
const char **ret;
*val = '\0';
val++;
- ret = lp_parm_string_list(s->snum, parm, val, ",;");
+ ret = lp_parm_string_list(s, parm, val, ",;");
talloc_free(parm);
return ret;
}
if (strcmp(opt_name, SHARE_HOSTS_ALLOW) == 0) {
- return lp_hostsallow(s->snum);
+ return lp_hostsallow(s);
}
if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) {
- return lp_hostsdeny(s->snum);
+ return lp_hostsdeny(s);
}
if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) {
- return lp_ntvfs_handler(s->snum);
+ return lp_ntvfs_handler(s);
}
DEBUG(0,("request for unknown share list option '%s'\n",
return NULL;
}
-NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
- struct share_context *ctx,
- int *count,
- const char ***names)
+static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
+ struct share_context *ctx,
+ int *count,
+ const char ***names)
{
int i;
int num_services;
}
for (i = 0; i < num_services; i++) {
- n[i] = talloc_strdup(n, lp_servicename(i));
+ n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum(i)));
if (!n[i]) {
DEBUG(0,("ERROR: Out of memory!\n"));
talloc_free(n);
return NT_STATUS_OK;
}
-NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx,
- struct share_context *ctx,
- const char *name,
- struct share_config **scfg)
+static NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx,
+ struct share_context *ctx,
+ const char *name,
+ struct share_config **scfg)
{
- int i, snum;
struct share_config *s;
- struct sclassic_snum *scnum;
+ struct service *service;
- snum = -1;
- for (i = 0; i < lp_numservices(); i++) {
- if (strcasecmp_m(name, lp_servicename(i)) == 0) {
- snum = i;
- break;
- }
- }
+ service = lp_service(name);
- if (snum < 0) {
+ if (service == NULL) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
return NT_STATUS_NO_MEMORY;
}
- s->name = talloc_strdup(s, lp_servicename(snum));
+ s->name = talloc_strdup(s, lp_servicename(service));
if (!s->name) {
DEBUG(0,("ERROR: Out of memory!\n"));
talloc_free(s);
return NT_STATUS_NO_MEMORY;
}
- scnum = talloc(s, struct sclassic_snum);
- if (!scnum) {
- DEBUG(0,("ERROR: Out of memory!\n"));
- talloc_free(s);
- return NT_STATUS_NO_MEMORY;
- }
- scnum->snum = snum;
-
- s->opaque = (void *)scnum;
+ s->opaque = (void *)service;
s->ctx = ctx;
*scfg = s;
{
enum srvsvc_PlatformId id;
- id = lp_parm_int(-1, "server_info", "platform_id", PLATFORM_ID_NT);
+ id = lp_parm_int(NULL, "server_info", "platform_id", PLATFORM_ID_NT);
return id;
}
/* This hardcoded value should go into a ldb database! */
_PUBLIC_ uint32_t dcesrv_common_get_version_major(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx)
{
- return lp_parm_int(-1, "server_info", "version_major", 5);
+ return lp_parm_int(NULL, "server_info", "version_major", 5);
}
/* This hardcoded value should go into a ldb database! */
_PUBLIC_ uint32_t dcesrv_common_get_version_minor(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx)
{
- return lp_parm_int(-1, "server_info", "version_minor", 2);
+ return lp_parm_int(NULL, "server_info", "version_minor", 2);
}
/* This hardcoded value should go into a ldb database! */
_PUBLIC_ uint32_t dcesrv_common_get_version_build(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx)
{
- return lp_parm_int(-1, "server_info", "version_build", 3790);
+ return lp_parm_int(NULL, "server_info", "version_build", 3790);
}
/* This hardcoded value should go into a ldb database! */
NTSTATUS status;
const struct ndr_interface_table *table;
struct dcesrv_remote_private *private;
- const char *binding = lp_parm_string(-1, "dcerpc_remote", "binding");
+ const char *binding = lp_parm_string(NULL, "dcerpc_remote", "binding");
const char *user, *pass, *domain;
struct cli_credentials *credentials;
BOOL machine_account;
- machine_account = lp_parm_bool(-1, "dcerpc_remote", "use_machine_account", False);
+ machine_account = lp_parm_bool(NULL, "dcerpc_remote", "use_machine_account", false);
private = talloc(dce_call->conn, struct dcesrv_remote_private);
if (!private) {
return NT_STATUS_INVALID_PARAMETER;
}
- user = lp_parm_string(-1, "dcerpc_remote", "user");
- pass = lp_parm_string(-1, "dcerpc_remote", "password");
- domain = lp_parm_string(-1, "dceprc_remote", "domain");
+ user = lp_parm_string(NULL, "dcerpc_remote", "user");
+ pass = lp_parm_string(NULL, "dcerpc_remote", "password");
+ domain = lp_parm_string(NULL, "dceprc_remote", "domain");
table = ndr_table_by_uuid(&iface->syntax_id.uuid); /* FIXME: What about if_version ? */
if (!table) {
static NTSTATUS remote_op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
{
int i;
- const char **ifaces = str_list_make(dce_ctx, lp_parm_string(-1,"dcerpc_remote","interfaces"),NULL);
+ const char **ifaces = str_list_make(dce_ctx, lp_parm_string(NULL,"dcerpc_remote","interfaces"),NULL);
if (!ifaces) {
DEBUG(3,("remote_op_init_server: no interfaces configured\n"));
my %smap = (
"GLOBAL" => "void",
- "LOCAL" => "int "
+ "LOCAL" => "struct service *"
);
$file->("$tmap{$type}$name($smap{$scope});\n");
const uint8_t *r, uint32_t length)
{
DATA_BLOB blob;
- blob.data = discard_const(r);
+ blob.data = (uint8_t *)discard_const(r);
blob.length = length;
mprSetVar(v, name, mprDataBlob(blob));
return NT_STATUS_OK;
if (argc != 0) return -1;
for (i=0;i<lp_numservices();i++) {
- list = str_list_add(list, lp_servicename(i));
+ list = str_list_add(list, lp_servicename(lp_servicebynum(i)));
}
talloc_steal(mprMemCtx(), list);
mpr_Return(eid, mprList("services", list));
if (argc < 1) return -1;
if (argc == 2) {
+ struct service *service;
/* its a share parameter */
- int snum = lp_servicenumber(argv[0]);
- if (snum == -1) {
+ service = lp_service(argv[0]);
+ if (service == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- value = lp_get_parametric(snum, type, option);
+ value = lp_get_parametric(service, type, option);
if (value == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- parm_ptr = lp_parm_ptr(snum, parm);
+ parm_ptr = lp_parm_ptr(service, parm);
} else if (strchr(argv[0], ':')) {
/* its a global parametric option */
const char *type = talloc_strndup(mprMemCtx(),
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- value = lp_get_parametric(-1, type, option);
+ value = lp_get_parametric(NULL, type, option);
if (value == NULL) {
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
mpr_Return(eid, mprCreateUndefinedVar());
return 0;
}
- parm_ptr = lp_parm_ptr(-1, parm);
+ parm_ptr = lp_parm_ptr(NULL, parm);
}
if (parm == NULL || parm_ptr == NULL) {
my ($self, $state, $testname, $result, $unexpected, $reason) = @_;
if ($unexpected and $self->{immediate} and not $self->{verbose}) {
- print "$testname: $result [ $reason ]\n";
+ if ($reason) {
+ print "$testname: $result [ $reason ]\n";
+ } else {
+ print "$testname: $result\n";
+ }
print $self->{test_output}->{$state->{NAME}}."\n";
}
$self->{test_output}->{$state->{NAME}} = "";
req->in.size = NBT_HDR_SIZE+SMB2_HDR_BODY+body_fixed_size;
req->in.allocated = req->in.size;
- req->in.buffer = talloc_size(req, req->in.allocated);
+ req->in.buffer = talloc_array(req, uint8_t, req->in.allocated);
if (!req->in.buffer) goto nomem;
req->in.hdr = req->in.buffer + NBT_HDR_SIZE;
req->in.body = req->in.hdr + SMB2_HDR_BODY;
req->out.size = SMB2_HDR_BODY+NBT_HDR_SIZE+body_fixed_size;
req->out.allocated = req->out.size + body_dynamic_size;
- req->out.buffer = talloc_size(req, req->out.allocated);
+ req->out.buffer = talloc_array(req, uint8_t,
+ req->out.allocated);
NT_STATUS_HAVE_NO_MEMORY(req->out.buffer);
req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
req = smb2srv_init_request(handle->tcon->smb_conn);
NT_STATUS_HAVE_NO_MEMORY(req);
- req->in.buffer = talloc_size(req, NBT_HDR_SIZE + SMB2_MIN_SIZE);
+ req->in.buffer = talloc_array(req, uint8_t,
+ NBT_HDR_SIZE + SMB2_MIN_SIZE);
NT_STATUS_HAVE_NO_MEMORY(req->in.buffer);
req->in.size = NBT_HDR_SIZE + SMB2_MIN_SIZE;
req->in.allocated = req->in.size;
srv_conn->event.fde = event_add_fd(ev, srv_conn, socket_get_fd(sock),
0, stream_io_handler_fde, srv_conn);
- if (!socket_check_access(sock, "smbd", lp_hostsallow(-1), lp_hostsdeny(-1))) {
+ if (!socket_check_access(sock, "smbd", lp_hostsallow(NULL), lp_hostsdeny(NULL))) {
stream_terminate_connection(srv_conn, "denied by access rules");
return;
}
gensec_start_mech_by_oid(gensec_security, GENSEC_OID_NTLMSSP),
"Failed to start GENSEC for NTLMSSP");
- gensec_ntlmssp_state = gensec_security->private_data;
+ gensec_ntlmssp_state = (struct gensec_ntlmssp_state *)gensec_security->private_data;
gensec_ntlmssp_state->session_key = strhex_to_data_blob("0102030405060708090a0b0c0d0e0f00");
dump_data_pw("NTLMSSP session key: \n",
gensec_start_mech_by_oid(gensec_security, GENSEC_OID_NTLMSSP),
"GENSEC start mech by oid");
- gensec_ntlmssp_state = gensec_security->private_data;
+ gensec_ntlmssp_state = (struct gensec_ntlmssp_state *)gensec_security->private_data;
gensec_ntlmssp_state->session_key = strhex_to_data_blob("0102030405e538b0");
dump_data_pw("NTLMSSP session key: \n",
return ret;
}
-BOOL torture_cldap(struct torture_context *torture)
+bool torture_cldap(struct torture_context *torture)
{
TALLOC_CTX *mem_ctx;
- BOOL ret = True;
+ bool ret = true;
const char *host = torture_setting_string(torture, "host", NULL);
mem_ctx = talloc_init("torture_cldap");
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
+ if (lp_parm_bool(NULL, "become dc", "dump objects", false)) {
for (i=0; i < objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
return werror_to_ntstatus(status);
}
- if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
+ if (lp_parm_bool(NULL, "become dc", "dump objects", false)) {
for (i=0; i < objs->num_objects; i++) {
struct ldb_ldif ldif;
fprintf(stdout, "#\n");
return NT_STATUS_FOOBAR;
}
- if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
+ if (lp_parm_bool(NULL, "become dc", "dump objects", false)) {
DEBUG(0,("# %s\n", sa->lDAPDisplayName));
NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
dump_data(0,
s = talloc_zero(torture, struct test_become_dc_state);
if (!s) return False;
- s->netbios_name = lp_parm_string(-1, "become dc", "smbtorture dc");
+ s->netbios_name = lp_parm_string(NULL, "become dc", "smbtorture dc");
if (!s->netbios_name || !s->netbios_name[0]) {
s->netbios_name = "smbtorturedc";
}
goto cleanup;
}
- if (lp_parm_bool(-1, "become dc", "do not unjoin", false)) {
+ if (lp_parm_bool(NULL, "become dc", "do not unjoin", false)) {
talloc_free(s);
return ret;
}
case acct_expiry:
continue_if_field_set(r->in.acct_expiry);
now = timeval_add(&now, (random() % (31*24*60*60)), 0);
- r->in.acct_expiry = talloc_memdup(mem_ctx, &now, sizeof(now));
+ r->in.acct_expiry = (struct timeval *)talloc_memdup(mem_ctx, &now, sizeof(now));
fldname = "acct_expiry";
break;
}
-BOOL torture_userinfo(struct torture_context *torture)
+bool torture_userinfo(struct torture_context *torture)
{
NTSTATUS status;
struct dcerpc_pipe *p;
case acct_expiry:
continue_if_field_set(mod->in.change.acct_expiry);
now = timeval_add(&now, (random() % (31*24*60*60)), 0);
- mod->in.change.acct_expiry = talloc_memdup(mem_ctx, &now, sizeof(now));
+ mod->in.change.acct_expiry = (struct timeval *)talloc_memdup(mem_ctx, &now, sizeof(now));
mod->in.change.fields |= USERMOD_FIELD_ACCT_EXPIRY;
fldname = "acct_expiry";
break;
}
-BOOL torture_userdel(struct torture_context *torture)
+bool torture_userdel(struct torture_context *torture)
{
NTSTATUS status;
struct dcerpc_pipe *p;
float tdb_speed;
-static BOOL tdb_add_record(struct tdb_wrap *tdbw, const char *fmt1, const char *fmt2, int i)
+static bool tdb_add_record(struct tdb_wrap *tdbw, const char *fmt1,
+ const char *fmt2, int i)
{
TDB_DATA key, data;
int ret;
static void fde_handler(struct event_context *ev_ctx, struct fd_event *f,
uint16_t flags, void *private)
{
- int *fd = private;
+ int *fd = (int *)private;
char c;
#ifdef SA_SIGINFO
kill(getpid(), SIGUSR1);
static void finished_handler(struct event_context *ev_ctx, struct timed_event *te,
struct timeval tval, void *private)
{
- int *finished = private;
+ int *finished = (int *)private;
(*finished) = 1;
}
static void count_handler(struct event_context *ev_ctx, struct signal_event *te,
int signum, int count, void *info, void *private)
{
- int *countp = private;
+ int *countp = (int *)private;
(*countp) += count;
}
{
iconv_t cd;
- if (!lp_parm_bool(-1, "iconv", "native", true))
+ if (!lp_parm_bool(NULL, "iconv", "native", true))
torture_skip(tctx, "system iconv disabled - skipping test");
cd = iconv_open("UTF-16LE", "UCS-4LE");
static bool test_next_codepoint(struct torture_context *tctx)
{
+ unsigned int codepoint;
if (iconv_untestable(tctx))
return true;
- unsigned int codepoint;
for (codepoint=0;codepoint<(1<<20);codepoint++) {
if (!test_codepoint(tctx, codepoint))
return false;
struct torture_suite *suite = torture_suite_create(mem_ctx, "ICONV");
torture_suite_add_simple_test(suite, "next_codepoint()",
- test_next_codepoint);
+ test_next_codepoint);
torture_suite_add_simple_test(suite, "first 1M codepoints",
- test_first_1m);
+ test_first_1m);
torture_suite_add_simple_test(suite, "5M random UTF-16LE sequences",
- test_random_5m);
+ test_random_5m);
return suite;
}
{
struct echo_AddOne r;
NTSTATUS status;
- const struct irpc_test_data *data = _data;
+ const struct irpc_test_data *data = (const struct irpc_test_data *)_data;
uint32_t value = (uint32_t)_value;
/* make the call */
{
struct echo_EchoData r;
NTSTATUS status;
- const struct irpc_test_data *data = tcase_data;
+ const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
TALLOC_CTX *mem_ctx = tctx;
/* make the call */
static void irpc_callback(struct irpc_request *irpc)
{
- struct echo_AddOne *r = irpc->r;
+ struct echo_AddOne *r = (struct echo_AddOne *)irpc->r;
int *pong_count = (int *)irpc->async.private;
NTSTATUS status = irpc_call_recv(irpc);
if (!NT_STATUS_IS_OK(status)) {
{
int ping_count = 0;
int pong_count = 0;
- const struct irpc_test_data *data = tcase_data;
+ const struct irpc_test_data *data = (const struct irpc_test_data *)tcase_data;
struct timeval tv;
struct echo_AddOne r;
TALLOC_CTX *mem_ctx = tctx;
{
struct security_descriptor *sd, *sd2;
struct dom_sid *domain;
- const char *sddl = test_data;
+ const char *sddl = (const char *)test_data;
const char *sddl2;
TALLOC_CTX *mem_ctx = tctx;
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
int count;
const char **names;
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
int count;
const char **names;
int i;
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
NTSTATUS status;
status = share_create(ctx, "bla", NULL, 0);
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
NTSTATUS status;
status = share_remove(ctx, "nonexistant");
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
struct share_info inf[] = {
{ SHARE_INFO_STRING, SHARE_TYPE, discard_const_p(void *, "IPC$") },
{ SHARE_INFO_STRING, SHARE_PATH, discard_const_p(void *, "/tmp/bla") }
const void *tcase_data,
const void *test_data)
{
- struct share_context *ctx = discard_const(tcase_data);
+ struct share_context *ctx = (struct share_context *)discard_const(tcase_data);
struct share_info inf[] = {
{ SHARE_INFO_STRING, SHARE_TYPE, discard_const_p(void *, "IPC$") },
{ SHARE_INFO_STRING, SHARE_PATH, discard_const_p(void *, "/tmp/bla") }
char **unc_list = NULL;
int num_unc_names;
const char *p;
- p = lp_parm_string(-1, "torture", "unclist");
+ p = lp_parm_string(NULL, "torture", "unclist");
if (p) {
char *h, *s;
unc_list = file_lines_load(p, &num_unc_names, NULL);
};
static bool lsarlookupsids3_out_check(struct torture_context *tctx,
- struct lsa_LookupSids3 *r)
+ struct lsa_LookupSids3 *r)
{
/* FIXME: Handle */
torture_assert(tctx, r->out.names != NULL, "names ptr");
struct torture_test *test)
{
bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;
- const struct ndr_pull_test_data *data = test->data;
+ const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
void *ds = talloc_zero_size(tctx, data->struct_size);
struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);
};
static bool querymultiplevalues_in_check(struct torture_context *tctx,
- struct winreg_QueryMultipleValues *r)
+ struct winreg_QueryMultipleValues *r)
{
torture_assert_int_equal(tctx, r->in.num_values, 1, "num values");
torture_assert_str_equal(tctx, r->in.values[0].name->name, "HOMEPATH",
};
static bool querymultiplevalues_out_check(struct torture_context *tctx,
- struct winreg_QueryMultipleValues *r)
+ struct winreg_QueryMultipleValues *r)
{
torture_assert_str_equal(tctx, r->out.values[0].name->name, "HOMEPATH",
"name");
};
static bool getkeysecurity_in_check(struct torture_context *tctx,
- struct winreg_GetKeySecurity *r)
+ struct winreg_GetKeySecurity *r)
{
/* FIXME: Handle */
torture_assert_int_equal(tctx, r->in.sec_info, 2, "sec info");
};
static bool getkeysecurity_out_check(struct torture_context *tctx,
- struct winreg_GetKeySecurity *r)
+ struct winreg_GetKeySecurity *r)
{
torture_assert_int_equal(tctx, r->in.sd->size, 20, "sd size");
torture_assert_int_equal(tctx, r->in.sd->len, 20, "sd len");
*/
bool torture_raw_acls(struct torture_context *tctx, struct smbcli_state *cli)
{
- BOOL ret = True;
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
return false;
printf("waiting for completion\n");
while (*count != num_ops) {
event_loop_once(cli->transport->socket->event.ctx);
- if (lp_parm_bool(-1, "torture", "progress", true)) {
+ if (lp_parm_bool(NULL, "torture", "progress", true)) {
printf("count=%d\r", *count);
fflush(stdout);
}
return False;
}
- io2.in.dest_host = lp_parm_string(-1, "torture", "host");
+ io2.in.dest_host = lp_parm_string(NULL, "torture", "host");
io2.in.port = 0;
- io2.in.called_name = lp_parm_string(-1, "torture", "host");
- io2.in.service = lp_parm_string(-1, "torture", "share");
+ io2.in.called_name = lp_parm_string(NULL, "torture", "host");
+ io2.in.service = lp_parm_string(NULL, "torture", "share");
io2.in.service_type = "A:";
io2.in.credentials = cmdline_credentials;
while (*count != torture_numops) {
event_loop_once(event_ctx);
- if (lp_parm_bool(-1, "torture", "progress", true)) {
+ if (lp_parm_bool(NULL, "torture", "progress", true)) {
printf("count=%d\r", *count);
fflush(stdout);
}
printf("waiting for completion\n");
while (*count != num_ops) {
event_loop_once(event_ctx);
- if (lp_parm_bool(-1, "torture", "progress", true)) {
+ if (lp_parm_bool(NULL, "torture", "progress", true)) {
printf("count=%d\r", *count);
fflush(stdout);
}
int *count = talloc_zero(mem_ctx, int);
BOOL ret = True;
- io1.in.dest_host = lp_parm_string(-1, "torture", "host");
+ io1.in.dest_host = lp_parm_string(NULL, "torture", "host");
io1.in.port = 0;
- io1.in.called_name = lp_parm_string(-1, "torture", "host");
- io1.in.service = lp_parm_string(-1, "torture", "share");
+ io1.in.called_name = lp_parm_string(NULL, "torture", "host");
+ io1.in.service = lp_parm_string(NULL, "torture", "share");
io1.in.service_type = "A:";
io1.in.credentials = cmdline_credentials;
io1.in.workgroup = lp_workgroup();
while (*count < torture_numops) {
event_loop_once(event_ctx);
- if (lp_parm_bool(-1, "torture", "progress", true)) {
+ if (lp_parm_bool(NULL, "torture", "progress", true)) {
printf("count=%d\r", *count);
fflush(stdout);
}
return False;
}
- share = lp_parm_string(-1, "torture", "share");
- host = lp_parm_string(-1, "torture", "host");
+ share = lp_parm_string(NULL, "torture", "share");
+ host = lp_parm_string(NULL, "torture", "host");
printf("create a second tree context on the same session\n");
tree = smbcli_tree_init(cli->session, mem_ctx, False);
return False;
}
- share = lp_parm_string(-1, "torture", "share");
- host = lp_parm_string(-1, "torture", "host");
+ share = lp_parm_string(NULL, "torture", "share");
+ host = lp_parm_string(NULL, "torture", "host");
printf("create the first new sessions\n");
session1 = smbcli_session_init(cli->transport, mem_ctx, False);
return False;
}
- share = lp_parm_string(-1, "torture", "share");
- host = lp_parm_string(-1, "torture", "host");
+ share = lp_parm_string(NULL, "torture", "share");
+ host = lp_parm_string(NULL, "torture", "host");
printf("create a second tree context on the same session\n");
tree = smbcli_tree_init(cli->session, mem_ctx, False);
printf("TESTING SETFILEINFO MAX. EA_SET\n");
- maxeasize = lp_parm_int(-1, "torture", "maxeasize", 65536);
- maxeanames = lp_parm_int(-1, "torture", "maxeanames", 101);
- maxeastart = lp_parm_int(-1, "torture", "maxeastart", 1);
- maxeadebug = lp_parm_int(-1, "torture", "maxeadebug", 0);
+ maxeasize = lp_parm_int(NULL, "torture", "maxeasize", 65536);
+ maxeanames = lp_parm_int(NULL, "torture", "maxeanames", 101);
+ maxeastart = lp_parm_int(NULL, "torture", "maxeastart", 1);
+ maxeadebug = lp_parm_int(NULL, "torture", "maxeadebug", 0);
/* Do some sanity check on possibly passed parms */
if (maxeasize <= 0) {
*/
bool torture_raw_eas(struct torture_context *torture, struct smbcli_state *cli)
{
- BOOL ret = True;
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
session->vuid = setup.out.vuid;
printf("create new tree context\n");
- share = lp_parm_string(-1, "torture", "share");
- host = lp_parm_string(-1, "torture", "host");
+ share = lp_parm_string(NULL, "torture", "share");
+ host = lp_parm_string(NULL, "torture", "host");
tree = smbcli_tree_init(session, tctx, False);
tcon.generic.level = RAW_TCON_TCONX;
tcon.tconx.in.flags = 0;
progress = torture_setting_bool(torture, "progress", true);
- nprocs = lp_parm_int(-1, "torture", "nprocs", 4);
+ nprocs = lp_parm_int(NULL, "torture", "nprocs", 4);
state = talloc_zero_array(mem_ctx, struct benchlock_state, nprocs);
md.t2mkdir.in.eas[2].value = data_blob_talloc(mem_ctx, "xx1", 3);
status = smb_raw_mkdir(cli->tree, &md);
- if (lp_parm_bool(-1, "torture", "samba3", False)
+ if (lp_parm_bool(NULL, "torture", "samba3", false)
&& NT_STATUS_EQUAL(status, NT_STATUS_EAS_NOT_SUPPORTED)) {
d_printf("EAS not supported -- not treating as fatal\n");
}
io.writex.in.wmode = 0;
io.writex.in.remaining = 0;
io.writex.in.count = 4;
- io.writex.in.data = (void *)&fnum;
+ io.writex.in.data = (const uint8_t *)&fnum;
req = smb_raw_write_send(cli->tree, &io);
/* unlock the range */
union smb_open io;
int fnum;
struct smbcli_request *req1, *req2;
- union smb_setfileinfo sfinfo;
printf("TESTING CHANGE NOTIFY WITH MASK CHANGE\n");
NOTIFY_ACTION_MODIFIED,
FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
printf("Samba3 does not yet support create times "
"everywhere\n");
}
io.openx.in.file_attrs = FILE_ATTRIBUTE_SYSTEM;
status = smb_raw_open(cli->tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
CHECK_ALL_INFO(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE,
attrib & ~(FILE_ATTRIBUTE_NONINDEXED|
FILE_ATTRIBUTE_SPARSE));
status = smb_raw_open(cli->tree, mem_ctx, &io);
if ((io.t2open.in.num_eas != 0)
&& NT_STATUS_EQUAL(status, NT_STATUS_EAS_NOT_SUPPORTED)
- && lp_parm_bool(-1, "torture", "samba3", False)) {
+ && lp_parm_bool(NULL, "torture", "samba3", false)) {
printf("(%s) EAs not supported, not treating as fatal "
"in Samba3 test\n", __location__);
io.t2open.in.num_eas = 0;
struct smbcli_state **clients;
struct smbcli_request **requests;
union smb_open *ios;
- const char *host = lp_parm_string(-1, "torture", "host");
- const char *share = lp_parm_string(-1, "torture", "share");
+ const char *host = lp_parm_string(NULL, "torture", "host");
+ const char *share = lp_parm_string(NULL, "torture", "share");
int i, num_files = 3;
struct event_context *ev;
int num_ok = 0;
#include "torture/util.h"
#include "param/param.h"
-
-
-
-void lock_byte(struct smbcli_state *cli, int fd, int offset, int lock_timeout)
+static void lock_byte(struct smbcli_state *cli, int fd, int offset, int lock_timeout)
{
union smb_lock io;
struct smb_lock_entry lock;
}
}
-void unlock_byte(struct smbcli_state *cli, int fd, int offset)
+static void unlock_byte(struct smbcli_state *cli, int fd, int offset)
{
union smb_lock io;
struct smb_lock_entry lock;
}
}
-void write_byte(struct smbcli_state *cli, int fd, uint8_t c, int offset)
+static void write_byte(struct smbcli_state *cli, int fd, uint8_t c, int offset)
{
union smb_write io;
NTSTATUS status;
}
}
-void read_byte(struct smbcli_state *cli, int fd, uint8_t *c, int offset)
+static void read_byte(struct smbcli_state *cli, int fd, uint8_t *c, int offset)
{
union smb_read io;
NTSTATUS status;
/*
ping pong
*/
-BOOL torture_ping_pong(struct torture_context *torture)
+bool torture_ping_pong(struct torture_context *torture)
{
const char *fn;
int num_locks;
uint8_t *val;
int count, loops;
- fn = lp_parm_string(-1, "torture", "filename");
+ fn = lp_parm_string(NULL, "torture", "filename");
if (fn == NULL) {
DEBUG(0,("You must specify the filename using --option=torture:filename=...\n"));
return false;
}
- num_locks = lp_parm_int(-1, "torture", "num_locks", -1);
+ num_locks = lp_parm_int(NULL, "torture", "num_locks", -1);
if (num_locks == -1) {
DEBUG(0,("You must specify num_locks using --option=torture:num_locks=...\n"));
return false;
}
- do_reads = lp_parm_bool(-1, "torture", "read", False);
- do_writes = lp_parm_bool(-1, "torture", "write", False);
- lock_timeout = lp_parm_int(-1, "torture", "lock_timeout", 100000);
+ do_reads = lp_parm_bool(NULL, "torture", "read", false);
+ do_writes = lp_parm_bool(NULL, "torture", "write", false);
+ lock_timeout = lp_parm_int(NULL, "torture", "lock_timeout", 100000);
if (!torture_open_connection(&cli, 0)) {
DEBUG(0,("Could not open connection\n"));
quiescent, which is sometimes hard to achieve
*/
bool torture_raw_qfsinfo(struct torture_context *torture,
- struct smbcli_state *cli)
+ struct smbcli_state *cli)
{
int i;
BOOL ret = True;
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(io.readx.out.remaining, 0xFFFF);
CHECK_VALUE(io.readx.out.compaction_mode, 0);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
printf("SAMBA3: large read extension\n");
CHECK_VALUE(io.readx.out.nread, 80000);
} else {
io.readx.in.maxcnt = 0x10000;
status = smb_raw_read(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
printf("SAMBA3: large read extension\n");
CHECK_VALUE(io.readx.out.nread, 0x10000);
} else {
io.readx.in.maxcnt = 0x10001;
status = smb_raw_read(cli->tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
printf("SAMBA3: large read extension\n");
CHECK_VALUE(io.readx.out.nread, 0x10001);
} else {
basic testing of streams calls
*/
bool torture_raw_streams(struct torture_context *torture,
- struct smbcli_state *cli)
+ struct smbcli_state *cli)
{
- BOOL ret = True;
+ bool ret = true;
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
io.unlink.in.attrib = FILE_ATTRIBUTE_DIRECTORY;
status = smb_raw_unlink(cli->tree, &io);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
/*
* In Samba3 we gave up upon getting the error codes in
* wildcard unlink correct. Trying gentest showed that this is
io.unlink.in.pattern = BASEDIR "\\t*";
io.unlink.in.attrib = FILE_ATTRIBUTE_DIRECTORY;
status = smb_raw_unlink(cli->tree, &io);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
}
else {
io.unlink.in.pattern = BASEDIR "\\*.dat";
io.unlink.in.attrib = FILE_ATTRIBUTE_DIRECTORY;
status = smb_raw_unlink(cli->tree, &io);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
}
else {
io.unlink.in.pattern = BASEDIR "\\*.tx?";
io.unlink.in.attrib = 0;
status = smb_raw_unlink(cli->tree, &io);
- if (lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba3", false)) {
CHECK_STATUS(status, NT_STATUS_NO_SUCH_FILE);
}
else {
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
- if (!lp_parm_bool(-1, "torture", "samba3", False)) {
+ if (!lp_parm_bool(NULL, "torture", "samba3", false)) {
/*
* Known deficiency, also skipped in base-delete.
talloc_free(*p);
- status = torture_rpc_connection(mem_ctx,
- p, iface);
+ status = torture_rpc_connection(mem_ctx, p, iface);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to reopen '%s' - %s\n", iface->name, nt_errstr(status));
exit(1);
{
struct timeval tv = timeval_current();
BOOL ret = True;
- int timelimit = lp_parm_int(-1, "torture", "timelimit", 10);
+ int timelimit = lp_parm_int(NULL, "torture", "timelimit", 10);
int count=0;
printf("Running for %d seconds\n", timelimit);
talloc_free(tmp_ctx);
count++;
if (count % 50 == 0) {
- if (lp_parm_bool(-1, "torture", "progress", true)) {
+ if (lp_parm_bool(NULL, "torture", "progress", true)) {
printf("%.1f queries per second \r",
count / timeval_elapsed(&tv));
}
if (!mem_ctx) {
return False;
}
- iface_name = lp_parm_string(-1, "countcalls", "interface");
+ iface_name = lp_parm_string(NULL, "countcalls", "interface");
if (iface_name != NULL) {
iface = ndr_table_by_name(iface_name);
if (!iface) {
r.in.req.req5.highwatermark.highest_usn = 0;
r.in.req.req5.uptodateness_vector = NULL;
r.in.req.req5.replica_flags = 0;
- if (lp_parm_bool(-1, "drsuapi", "compression", false)) {
+ if (lp_parm_bool(NULL, "drsuapi", "compression", false)) {
r.in.req.req5.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
}
r.in.req.req5.max_object_count = 0;
r.in.req.req8.highwatermark.highest_usn = 0;
r.in.req.req8.uptodateness_vector = NULL;
r.in.req.req8.replica_flags = 0;
- if (lp_parm_bool(-1, "drsuapi", "compression", false)) {
+ if (lp_parm_bool(NULL, "drsuapi", "compression", false)) {
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
}
- if (lp_parm_bool(-1, "drsuapi", "neighbour_writeable",true)) {
+ if (lp_parm_bool(NULL, "drsuapi", "neighbour_writeable",true)) {
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE;
}
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
struct DsSyncTest *ctx;
struct drsuapi_DsBindInfo28 *our_bind_info28;
struct drsuapi_DsBindInfoCtr *our_bind_info_ctr;
- const char *binding = lp_parm_string(-1, "torture", "binding");
+ const char *binding = lp_parm_string(NULL, "torture", "binding");
ctx = talloc_zero(mem_ctx, struct DsSyncTest);
if (!ctx) return NULL;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
- if (lp_parm_bool(-1,"dssync","xpress",False)) {
+ if (lp_parm_bool(NULL, "dssync", "xpress", false)) {
our_bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
}
our_bind_info28->site_guid = GUID_zero();
static uint32_t object_id;
const char *save_values_dir;
- if (!lp_parm_bool(-1,"dssync","print_pwd_blobs", false)) {
+ if (!lp_parm_bool(NULL,"dssync","print_pwd_blobs", false)) {
return;
}
- save_values_dir = lp_parm_string(-1,"dssync","save_pwd_blobs_dir");
+ save_values_dir = lp_parm_string(NULL, "dssync", "save_pwd_blobs_dir");
for (; cur; cur = cur->next_object) {
const char *dn;
ZERO_STRUCT(null_guid);
ZERO_STRUCT(null_sid);
- partition = lp_parm_string(-1, "dssync", "partition");
+ partition = lp_parm_string(NULL, "dssync", "partition");
if (partition == NULL) {
partition = ctx->domain_dn;
printf("dssync:partition not specified, defaulting to %s.\n", ctx->domain_dn);
}
- highest_usn = lp_parm_int(-1, "dssync", "highest_usn", 0);
+ highest_usn = lp_parm_int(NULL, "dssync", "highest_usn", 0);
- array[0].level = lp_parm_int(-1, "dssync", "get_nc_changes_level", array[0].level);
+ array[0].level = lp_parm_int(NULL, "dssync", "get_nc_changes_level", array[0].level);
- if (lp_parm_bool(-1,"dssync","print_pwd_blobs",False)) {
+ if (lp_parm_bool(NULL, "dssync", "print_pwd_blobs", false)) {
const struct samr_Password *nthash;
nthash = cli_credentials_get_nt_hash(ctx->new_dc.credentials, ctx);
if (nthash) {
r.in.req.req5.highwatermark.highest_usn = highest_usn;
r.in.req.req5.uptodateness_vector = NULL;
r.in.req.req5.replica_flags = 0;
- if (lp_parm_bool(-1,"dssync","compression",False)) {
+ if (lp_parm_bool(NULL, "dssync", "compression", false)) {
r.in.req.req5.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
}
- if (lp_parm_bool(-1,"dssync","neighbour_writeable",True)) {
+ if (lp_parm_bool(NULL, "dssync", "neighbour_writeable", true)) {
r.in.req.req5.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE;
}
r.in.req.req5.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
r.in.req.req8.highwatermark.highest_usn = highest_usn;
r.in.req.req8.uptodateness_vector = NULL;
r.in.req.req8.replica_flags = 0;
- if (lp_parm_bool(-1,"dssync","compression",False)) {
+ if (lp_parm_bool(NULL, "dssync", "compression", false)) {
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
}
- if (lp_parm_bool(-1,"dssync","neighbour_writeable",True)) {
+ if (lp_parm_bool(NULL, "dssync", "neighbour_writeable", true)) {
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE;
}
r.in.req.req8.replica_flags |= DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
r.in.bind_handle = &ctx->new_dc.drsuapi.bind_handle;
r.in.level = 1;
- r.in.req.req1.unknown1 = lp_parm_int(-1, "dssync", "nt4-1", 3);
- r.in.req.req1.unknown2 = lp_parm_int(-1, "dssync", "nt4-2", 0x00004000);
+ r.in.req.req1.unknown1 = lp_parm_int(NULL, "dssync", "nt4-1", 3);
+ r.in.req.req1.unknown2 = lp_parm_int(NULL, "dssync", "nt4-2", 0x00004000);
while (1) {
r.in.req.req1.length = cookie.length;
return ret;
}
-BOOL torture_rpc_dssync(struct torture_context *torture)
+bool torture_rpc_dssync(struct torture_context *torture)
{
- BOOL ret = True;
+ bool ret = true;
TALLOC_CTX *mem_ctx;
struct DsSyncTest *ctx;
len = 1 + (random() % 5000);
}
- data_in = talloc_size(tctx, len);
- data_out = talloc_size(tctx, len);
+ data_in = talloc_array(tctx, uint8_t, len);
+ data_out = talloc_array(tctx, uint8_t, len);
for (i=0;i<len;i++) {
data_in[i] = i;
}
len = 200000 + (random() % 5000);
}
- data_in = talloc_size(tctx, len);
+ data_in = talloc_array(tctx, uint8_t, len);
for (i=0;i<len;i++) {
data_in[i] = i+1;
}
/* Now read the actual record */
r.in.number_of_bytes = *r.out.real_size;
- r.out.data = talloc_size(tctx, r.in.number_of_bytes);
+ r.out.data = talloc_array(tctx, uint8_t, r.in.number_of_bytes);
status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
NTSTATUS status;
struct lsa_QuerySecurity r;
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping QuerySecurity test against Samba4\n");
return True;
}
printf("\nTesting lsaRQueryForestTrustInformation\n");
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping QueryForestTrustInformation against Samba4\n");
return True;
}
NTSTATUS status;
int i;
BOOL ret = True;
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping QueryDomainInformationPolicy test against Samba4\n");
return True;
}
BOOL ret = True;
printf("\nTesting QueryInfoPolicy\n");
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping QueryInfoPolicy against Samba4\n");
return True;
}
int i;
BOOL ret = True;
printf("\nTesting QueryInfoPolicy2\n");
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping QueryInfoPolicy2 against Samba4\n");
return True;
}
static void async_callback(struct rpc_request *req)
{
- int *counter = req->async.private_data;
+ int *counter = (int *)req->async.private_data;
if (NT_STATUS_IS_OK(req->status)) {
(*counter)++;
}
for (i=0;i<ASYNC_COUNT;i++) {
creds_client_authenticator(creds, &a);
- creds_async[i] = talloc_memdup(creds, creds, sizeof(*creds));
+ creds_async[i] = (struct creds_CredentialState *)talloc_memdup(creds, creds, sizeof(*creds));
req[i] = dcerpc_netr_LogonGetDomainInfo_send(p, tctx, &r);
req[i]->async.callback = async_callback;
struct cli_credentials *wks_creds;
status = smbcli_full_connection(mem_ctx, &cli,
- lp_parm_string(-1, "torture", "host"),
+ lp_parm_string(NULL, "torture", "host"),
"IPC$", NULL, smb_creds, NULL);
if (!NT_STATUS_IS_OK(status)) {
d_printf("smbcli_full_connection failed: %s\n",
u.info21.fields_present = SAMR_FIELD_WORKSTATIONS | SAMR_FIELD_LOGON_HOURS;
u.info21.workstations.string = TEST_MACHINE_NAME;
u.info21.logon_hours.units_per_week = 168;
- u.info21.logon_hours.bits = talloc_zero_size(mem_ctx, 168);
+ u.info21.logon_hours.bits = talloc_zero_array(mem_ctx, uint8_t, 168);
status = dcerpc_samr_SetUserInfo(torture_join_samr_pipe(user_ctx_wrong_time), mem_ctx, &s);
if (!NT_STATUS_IS_OK(status)) {
NTSTATUS status;
struct samr_Shutdown r;
- if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
+ if (!lp_parm_bool(NULL, "torture", "dangerous", false)) {
printf("samr_Shutdown disabled - enable dangerous tests to use\n");
return True;
}
struct lsa_String string;
struct samr_Password hash;
- if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
+ if (!lp_parm_bool(NULL, "torture", "dangerous", false)) {
printf("samr_SetDsrmPassword disabled - enable dangerous tests to use\n");
return True;
}
s.in.sec_info = 7;
s.in.sdbuf = r.out.sdbuf;
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping SetSecurity test against Samba4\n");
return True;
}
TEST_USERINFO_INT(21, logon_hours.bits[3], 21, logon_hours.bits[3], 4,
SAMR_FIELD_LOGON_HOURS);
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping Set Account Flag tests against Samba4\n");
return ret;
}
ret = False;
}
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping MultipleMembers Alias tests against Samba4\n");
return ret;
}
#define ASYNC_COUNT 100
struct rpc_request *req[ASYNC_COUNT];
- if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
+ if (!lp_parm_bool(NULL, "torture", "dangerous", false)) {
printf("samr async test disabled - enable dangerous tests to use\n");
return True;
}
return False;
}
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping SetMemberAttributesOfGroup test against Samba4\n");
} else {
/* this one is quite strange. I am using random inputs in the
ret &= test_QueryDisplayInfo3(p, mem_ctx, &domain_handle);
ret &= test_QueryDisplayInfo_continue(p, mem_ctx, &domain_handle);
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
printf("skipping GetDisplayEnumerationIndex test against Samba4\n");
} else {
ret &= test_GetDisplayEnumerationIndex(p, mem_ctx, &domain_handle);
sizeof(ninfo.challenge));
if (nt_hash) {
ninfo.nt.length = 24;
- ninfo.nt.data = talloc_size(mem_ctx, 24);
+ ninfo.nt.data = talloc_array(mem_ctx, uint8_t, 24);
SMBOWFencrypt(nt_hash->hash, ninfo.challenge, ninfo.nt.data);
} else {
ninfo.nt.length = 0;
if (lm_hash) {
ninfo.lm.length = 24;
- ninfo.lm.data = talloc_size(mem_ctx, 24);
+ ninfo.lm.data = talloc_array(mem_ctx, uint8_t, 24);
SMBOWFencrypt(lm_hash->hash, ninfo.challenge, ninfo.lm.data);
} else {
ninfo.lm.length = 0;
{
struct test_join *join_ctx;
NTSTATUS status;
- const char *binding = lp_parm_string(-1, "torture", "binding");
+ const char *binding = lp_parm_string(NULL, "torture", "binding");
struct dcerpc_binding *b;
struct dcerpc_pipe *p = NULL;
struct dcerpc_pipe *p_netlogon = NULL;
torture_assert(torture, join_ctx != NULL,
"Failed to join domain with acct_flags=ACB_WSTRUST");
- credentials2 = talloc_memdup(torture, credentials1, sizeof(*credentials1));
+ credentials2 = (struct cli_credentials *)talloc_memdup(torture, credentials1, sizeof(*credentials1));
credentials1->netlogon_creds = NULL;
credentials2->netlogon_creds = NULL;
struct dcerpc_pipe *p;
struct policy_handle *handle;
struct dcerpc_binding *binding;
- const struct secret_settings *settings = _data;
+ const struct secret_settings *settings =
+ (const struct secret_settings *)_data;
lp_set_cmdline("ntlmssp client:keyexchange", settings->keyexchange?"True":"False");
lp_set_cmdline("ntlmssp_client:ntlm2", settings->ntlm2?"True":"False");
if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
r.in.buf_size = *r.out.bytes_needed;
- r.out.service = talloc_size(tctx, *r.out.bytes_needed);
+ r.out.service = talloc_array(tctx, uint8_t, *r.out.bytes_needed);
status = dcerpc_svcctl_EnumServicesStatusW(p, tctx, &r);
int policy_min_pw_len = 0;
struct test_join *join;
char *random_pw;
- const char *dc_binding = lp_parm_string(-1, "torture", "dc_binding");
+ const char *dc_binding = lp_parm_string(NULL, "torture", "dc_binding");
join = talloc(NULL, struct test_join);
if (join == NULL) {
tj->libnet_r = libnet_r;
libnet_ctx->cred = cmdline_credentials;
- libnet_r->in.binding = lp_parm_string(-1, "torture", "binding");
+ libnet_r->in.binding = lp_parm_string(NULL, "torture", "binding");
if (!libnet_r->in.binding) {
- libnet_r->in.binding = talloc_asprintf(libnet_r, "ncacn_np:%s", lp_parm_string(-1, "torture", "host"));
+ libnet_r->in.binding = talloc_asprintf(libnet_r, "ncacn_np:%s", lp_parm_string(NULL, "torture", "host"));
}
libnet_r->in.level = LIBNET_JOINDOMAIN_SPECIFIED;
libnet_r->in.netbios_name = machine_name;
DATA_BLOB data;
int i;
- if (lp_parm_bool(-1, "torture", "dangerous", False)) {
+ if (lp_parm_bool(NULL, "torture", "dangerous", false)) {
data = data_blob_talloc(tree, NULL, 160000);
- } else if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ } else if (lp_parm_bool(NULL, "torture", "samba4", false)) {
data = data_blob_talloc(tree, NULL, UINT16_MAX);
} else {
data = data_blob_talloc(tree, NULL, 120000);
file_levels[i].dinfo.query_secdesc.in.secinfo_flags = 0x7;
}
if (file_levels[i].level == RAW_FILEINFO_SMB2_ALL_EAS) {
- if (lp_parm_bool(-1, "torture", "samba4", False)) {
+ if (lp_parm_bool(NULL, "torture", "samba4", false)) {
continue;
}
file_levels[i].finfo.all_eas.in.continue_flags =
#include "system/time.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "param/param.h"
+#include "torture/smb2/proto.h"
/*
BOOL torture_smb2_connection(TALLOC_CTX *mem_ctx, struct smb2_tree **tree)
{
NTSTATUS status;
- const char *host = lp_parm_string(-1, "torture", "host");
- const char *share = lp_parm_string(-1, "torture", "share");
+ const char *host = lp_parm_string(NULL, "torture", "host");
+ const char *share = lp_parm_string(NULL, "torture", "share");
struct cli_credentials *credentials = cmdline_credentials;
status = smb2_connect(mem_ctx, host, share, credentials, tree,
int torture_setting_int(struct torture_context *test, const char *name,
int default_value)
{
- return lp_parm_int(-1, "torture", name, default_value);
+ return lp_parm_int(NULL, "torture", name, default_value);
}
double torture_setting_double(struct torture_context *test, const char *name,
double default_value)
{
- return lp_parm_double(-1, "torture", name, default_value);
+ return lp_parm_double(NULL, "torture", name, default_value);
}
bool torture_setting_bool(struct torture_context *test, const char *name,
bool default_value)
{
- return lp_parm_bool(-1, "torture", name, default_value);
+ return lp_parm_bool(NULL, "torture", name, default_value);
}
const char *torture_setting_string(struct torture_context *test, const char *name,
const char *default_value)
{
- const char *ret = lp_parm_string(-1, "torture", name);
+ const char *ret = lp_parm_string(NULL, "torture", name);
if (ret == NULL)
return default_value;
NTSTATUS status;
struct smbcli_state *cli;
- const char *host = lp_parm_string(-1, "torture", "host");
- const char *share = lp_parm_string(-1, "torture", "share");
+ const char *host = lp_parm_string(NULL, "torture", "host");
+ const char *share = lp_parm_string(NULL, "torture", "share");
status = smbcli_full_connection(mem_ctx, &cli,
host, share, NULL,
return False;
}
- (*c)->transport->options.use_oplocks = lp_parm_bool(-1, "torture",
- "use_oplocks", False);
- (*c)->transport->options.use_level2_oplocks = lp_parm_bool(-1, "torture",
- "use_level2_oplocks", False);
+ (*c)->transport->options.use_oplocks = lp_parm_bool(NULL, "torture",
+ "use_oplocks", false);
+ (*c)->transport->options.use_level2_oplocks = lp_parm_bool(NULL, "torture",
+ "use_level2_oplocks", false);
return True;
}
int num_unc_names = 0;
const char *p;
- (*host) = talloc_strdup(mem_ctx, lp_parm_string(-1, "torture", "host"));
- (*share) = talloc_strdup(mem_ctx, lp_parm_string(-1, "torture", "share"));
+ (*host) = talloc_strdup(mem_ctx, lp_parm_string(NULL, "torture", "host"));
+ (*share) = talloc_strdup(mem_ctx, lp_parm_string(NULL, "torture", "share"));
- p = lp_parm_string(-1, "torture", "unclist");
+ p = lp_parm_string(NULL, "torture", "unclist");
if (!p) {
return True;
}
ret = do_global_checks();
for (s=0;s<lp_numservices();s++) {
- if (lp_snum_ok(s))
- if (strlen(lp_servicename(s)) > 12) {
+ struct service *service = lp_servicebynum(s);
+ if (service != NULL)
+ if (strlen(lp_servicename(lp_servicebynum(s))) > 12) {
fprintf(stderr, "WARNING: You have some share names that are longer than 12 characters.\n" );
fprintf(stderr, "These may not be accessible to some older clients.\n" );
fprintf(stderr, "(Eg. Windows9x, WindowsMe, and not listed in smbclient in Samba 3.0.)\n" );
}
for (s=0;s<lp_numservices();s++) {
- if (lp_snum_ok(s)) {
- const char **deny_list = lp_hostsdeny(s);
- const char **allow_list = lp_hostsallow(s);
+ struct service *service = lp_servicebynum(s);
+ if (service != NULL) {
+ const char **deny_list = lp_hostsdeny(service);
+ const char **allow_list = lp_hostsallow(service);
int i;
if(deny_list) {
for (i=0; deny_list[i]; i++) {
char *hasquery = strchr_m(deny_list[i], '?');
if(hasstar || hasquery) {
fprintf(stderr,"Invalid character %c in hosts deny list (%s) for service %s.\n",
- hasstar ? *hasstar : *hasquery, deny_list[i], lp_servicename(s) );
+ hasstar ? *hasstar : *hasquery, deny_list[i], lp_servicename(service) );
}
}
}
char *hasquery = strchr_m(allow_list[i], '?');
if(hasstar || hasquery) {
fprintf(stderr,"Invalid character %c in hosts allow list (%s) for service %s.\n",
- hasstar ? *hasstar : *hasquery, allow_list[i], lp_servicename(s) );
+ hasstar ? *hasstar : *hasquery, allow_list[i], lp_servicename(service) );
}
}
}
getc(stdin);
}
if (section_name || parameter_name) {
- BOOL isGlobal = False;
+ struct service *service = NULL;
if (!section_name) {
section_name = GLOBAL_NAME;
- isGlobal = True;
- } else if ((isGlobal=!strwicmp(section_name, GLOBAL_NAME)) == 0 &&
- (s=lp_servicenumber(section_name)) == -1) {
+ service = NULL;
+ } else if ((!strwicmp(section_name, GLOBAL_NAME)) == 0 &&
+ (service=lp_service(section_name)) == NULL) {
fprintf(stderr,"Unknown section %s\n",
section_name);
return(1);
}
if (!parameter_name) {
- if (isGlobal == True) {
- lp_dump(stdout, show_defaults, 0);
- } else {
- lp_dump_one(stdout, show_defaults, s);
- }
+ lp_dump_one(stdout, show_defaults, service);
} else {
- ret = !lp_dump_a_parameter(s, parameter_name, stdout, isGlobal);
+ ret = !lp_dump_a_parameter(s, parameter_name, stdout, (service == NULL));
}
} else {
lp_dump(stdout, show_defaults, lp_numservices());
if(cname && caddr){
/* this is totally ugly, a real `quick' hack */
for (s=0;s<lp_numservices();s++) {
- if (lp_snum_ok(s)) {
- if (allow_access(NULL, lp_hostsdeny(-1), lp_hostsallow(-1), cname, caddr)
- && allow_access(NULL, lp_hostsdeny(s), lp_hostsallow(s), cname, caddr)) {
+ struct service *service = lp_servicebynum(s);
+ if (service != NULL) {
+ if (allow_access(NULL, lp_hostsdeny(NULL), lp_hostsallow(NULL), cname, caddr)
+ && allow_access(NULL, lp_hostsdeny(service), lp_hostsallow(service), cname, caddr)) {
fprintf(stderr,"Allow connection from %s (%s) to %s\n",
- cname,caddr,lp_servicename(s));
+ cname,caddr,lp_servicename(service));
} else {
fprintf(stderr,"Deny connection from %s (%s) to %s\n",
- cname,caddr,lp_servicename(s));
+ cname,caddr,lp_servicename(service));
}
}
}
fd = open(path, O_RDONLY);
if (fd == -1 || fstat(fd, &st) != 0 || !S_ISREG(st.st_mode)) goto failed;
- *buf = talloc_size(handle, st.st_size+1);
+ *buf = talloc_array(handle, char, st.st_size+1);
if (*buf == NULL) goto failed;
if (read(fd, *buf, st.st_size) != st.st_size) goto failed;
s->data = NULL;
s->te = NULL;
s->edata = edata;
- s->lifetime = lp_parm_int(-1, "web", "sessiontimeout", 900);
+ s->lifetime = lp_parm_int(NULL, "web", "sessiontimeout", 900);
DLIST_ADD(edata->sessions, s);
talloc_set_destructor(s, session_destructor);
if (!generated_key) {
/* parse any lines that are available */
b = web->input.partial;
while (!web->input.end_of_headers &&
- (p=memchr(b.data, '\n', b.length))) {
+ (p=(uint8_t *)memchr(b.data, '\n', b.length))) {
const char *line = (const char *)b.data;
*p = 0;
if (p != b.data && p[-1] == '\r') {
}
/* the default renew interval is 6 days */
- service->config.renew_interval = lp_parm_int(-1,"wreplsrv","renew_interval", 6*24*60*60);
+ service->config.renew_interval = lp_parm_int(NULL,"wreplsrv","renew_interval", 6*24*60*60);
/* the default tombstone (extinction) interval is 6 days */
- service->config.tombstone_interval= lp_parm_int(-1,"wreplsrv","tombstone_interval", 6*24*60*60);
+ service->config.tombstone_interval= lp_parm_int(NULL,"wreplsrv","tombstone_interval", 6*24*60*60);
/* the default tombstone (extinction) timeout is 1 day */
- service->config.tombstone_timeout = lp_parm_int(-1,"wreplsrv","tombstone_timeout", 1*24*60*60);
+ service->config.tombstone_timeout = lp_parm_int(NULL,"wreplsrv","tombstone_timeout", 1*24*60*60);
/* the default tombstone extra timeout is 3 days */
- service->config.tombstone_extra_timeout = lp_parm_int(-1,"wreplsrv","tombstone_extra_timeout", 3*24*60*60);
+ service->config.tombstone_extra_timeout = lp_parm_int(NULL,"wreplsrv","tombstone_extra_timeout", 3*24*60*60);
/* the default verify interval is 24 days */
- service->config.verify_interval = lp_parm_int(-1,"wreplsrv","verify_interval", 24*24*60*60);
+ service->config.verify_interval = lp_parm_int(NULL,"wreplsrv","verify_interval", 24*24*60*60);
/* the default scavenging interval is 'renew_interval/2' */
- service->config.scavenging_interval=lp_parm_int(-1,"wreplsrv","scavenging_interval",
+ service->config.scavenging_interval=lp_parm_int(NULL,"wreplsrv","scavenging_interval",
service->config.renew_interval/2);
/* the maximun interval to the next periodic processing event */
- service->config.periodic_interval = lp_parm_int(-1,"wreplsrv","periodic_interval", 15);
+ service->config.periodic_interval = lp_parm_int(NULL,"wreplsrv","periodic_interval", 15);
return NT_STATUS_OK;
}
git.samba.org / nivanova / samba-autobuild / .git / commitdiff