return NT_STATUS_NO_MEMORY;
}
- generic_security_ops[gensec_num_backends] = discard_const(ops);
+ generic_security_ops[gensec_num_backends] = discard_const_p(struct gensec_security_ops, ops);
gensec_num_backends++;
generic_security_ops[gensec_num_backends] = NULL;
return nt_status;
}
- gensec_krb5_state = gensec_security->private_data;
+ gensec_krb5_state = (struct gensec_krb5_state *)gensec_security->private_data;
gensec_krb5_state->state_position = GENSEC_KRB5_SERVER_START;
return NT_STATUS_OK;
if (NT_STATUS_IS_OK(nt_status)) {
struct gensec_krb5_state *gensec_krb5_state;
- gensec_krb5_state = gensec_security->private_data;
+ gensec_krb5_state = (struct gensec_krb5_state *)gensec_security->private_data;
gensec_krb5_state->gssapi = True;
}
return nt_status;
return nt_status;
}
- gensec_krb5_state = gensec_security->private_data;
+ gensec_krb5_state = (struct gensec_krb5_state *)gensec_security->private_data;
gensec_krb5_state->state_position = GENSEC_KRB5_CLIENT_START;
principal = gensec_get_target_principal(gensec_security);
return WERR_OK;
}
-WERROR local_enum_key(TALLOC_CTX *mem_ctx,
+static WERROR local_enum_key(TALLOC_CTX *mem_ctx,
const struct registry_key *key, uint32_t idx,
const char **name,
const char **keyclass,
struct hive_key *hivekey;
const char **elements;
int i;
- char *last_part;
+ const char *last_part;
last_part = strrchr(name, '\\');
if (last_part == NULL) {
* Load diff file
*/
_PUBLIC_ WERROR reg_diff_load(const char *filename,
- const struct reg_diff_callbacks *callbacks,
- void *callback_data)
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data)
{
int fd;
char hdr[4];
*/
static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
{
- struct registry_context *ctx = _ctx;
+ struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
WERROR error;
static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
{
- struct registry_context *ctx = _ctx;
+ struct registry_context *ctx = (struct registry_context *)_ctx;
WERROR error;
error = reg_key_del_abs(ctx, key_name);
static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char *value_name, uint32_t value_type, DATA_BLOB value)
{
- struct registry_context *ctx = _ctx;
+ struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
WERROR error;
static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const char *value_name)
{
- struct registry_context *ctx = _ctx;
+ struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
WERROR error;
static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
{
- struct registry_context *ctx = _ctx;
+ struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *key;
WERROR error;
int i;
static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
{
- struct dotreg_data *data = _data;
+ struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\n[%s]\n", key_name);
static WERROR reg_dotreg_diff_del_key(void *_data, const char *key_name)
{
- struct dotreg_data *data = _data;
+ struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\n[-%s]\n", key_name);
static WERROR reg_dotreg_diff_set_value(void *_data, const char *path,
const char *value_name, uint32_t value_type, DATA_BLOB value)
{
- struct dotreg_data *data = _data;
+ struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\"%s\"=%s:%s\n",
value_name, str_regtype(value_type),
static WERROR reg_dotreg_diff_del_value(void *_data, const char *path, const char *value_name)
{
- struct dotreg_data *data = _data;
+ struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\"%s\"=-\n", value_name);
/**
* Load diff file
*/
-_PUBLIC_ WERROR reg_dotreg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data)
+_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+ const struct reg_diff_callbacks *callbacks, void *callback_data)
{
char *line, *p, *q;
char *curkey = NULL;
/* FIXME These functions need to be implemented */
static WERROR reg_preg_diff_add_key(void *_data, const char *key_name)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
static WERROR reg_preg_diff_del_key(void *_data, const char *key_name)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
static WERROR reg_preg_diff_set_value(void *_data, const char *key_name, const char *value_name, uint32_t value_type, DATA_BLOB value_data)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
static WERROR reg_preg_diff_del_value(void *_data, const char *key_name, const char *value_name)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
static WERROR reg_preg_diff_del_all_values(void *_data, const char *key_name)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
static WERROR reg_preg_diff_done(void *_data)
{
- struct preg_data *data = _data;
+ struct preg_data *data = (struct preg_data *)_data;
close(data->fd);
talloc_free(data);
* @brief Samba-specific registry functions
*/
-WERROR mount_samba_hive(struct registry_context *ctx,
+static WERROR mount_samba_hive(struct registry_context *ctx,
struct auth_session_info *auth_info,
struct cli_credentials *creds,
const char *name,
#include "includes.h"
#include "auth/credentials/credentials.h"
#include "lib/registry/registry.h"
+#include "lib/registry/tools/common.h"
struct registry_context *reg_common_open_remote(const char *remote, struct cli_credentials *creds)
{
*/
static void delete_fn(struct clilist_file_info *finfo, const char *name, void *state)
{
- struct delete_state *dstate = state;
+ struct delete_state *dstate = (struct delete_state *)state;
char *s, *n;
if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) {
return;
ssize_t smbcli_read(struct smbcli_tree *tree, int fnum, void *_buf, off_t offset,
size_t size)
{
- uint8_t *buf = _buf;
+ uint8_t *buf = (uint8_t *)_buf;
union smb_read parms;
int readsize;
ssize_t total = 0;
int fnum, uint16_t write_mode,
const void *_buf, off_t offset, size_t size)
{
- const uint8_t *buf = _buf;
+ const uint8_t *buf = (const uint8_t *)_buf;
union smb_write parms;
int block = (tree->session->transport->negotiate.max_xmit - (MIN_SMB_SIZE+32));
ssize_t total = 0;
ssize_t smbcli_smbwrite(struct smbcli_tree *tree,
int fnum, const void *_buf, off_t offset, size_t size1)
{
- const uint8_t *buf = _buf;
+ const uint8_t *buf = (const uint8_t *)_buf;
union smb_write parms;
ssize_t total = 0;
p->out.sequence_number = SVAL(req->in.vwv, VWV(0));
p->out.size = req->in.data_size;
talloc_free(p->out.data);
- p->out.data = talloc_size(mem_ctx, p->out.size);
+ p->out.data = talloc_array(mem_ctx, uint8_t, p->out.size);
NT_STATUS_HAVE_NO_MEMORY(p->out.data);
if (!smbcli_raw_pull_data(req, req->in.data, p->out.size, p->out.data)) {
if (size == -1) {
return NT_STATUS_ILLEGAL_CHARACTER;
}
- io->streams[n].stream_name.s = vstr;
+ io->streams[n].stream_name.s = (const char *)vstr;
io->streams[n].stream_name.private_length = nlen;
io->num_streams++;
len = IVAL(blob.data, ofs);
/* over allocate by a small amount */
req->out.allocated = req->out.size + REQ_OVER_ALLOCATION;
- req->out.buffer = talloc_size(req, req->out.allocated);
+ req->out.buffer = talloc_array(req, uint8_t, req->out.allocated);
if (!req->out.buffer) {
return NULL;
}
/* allocate it */
if (total_data != 0) {
- tdata = talloc_size(mem_ctx, total_data);
+ tdata = talloc_array(mem_ctx, uint8_t, total_data);
if (!tdata) {
DEBUG(0,("smb_raw_receive_trans: failed to enlarge data buffer to %d bytes\n", total_data));
req->status = NT_STATUS_NO_MEMORY;
}
if (total_param != 0) {
- tparam = talloc_size(mem_ctx, total_param);
+ tparam = talloc_array(mem_ctx, uint8_t, total_param);
if (!tparam) {
DEBUG(0,("smb_raw_receive_trans: failed to enlarge param buffer to %d bytes\n", total_param));
req->status = NT_STATUS_NO_MEMORY;
dynamic_ofs = buf->dynamic - buf->buffer;
- buffer_ptr = talloc_realloc_size(buf, buf->buffer, newsize);
+ buffer_ptr = talloc_realloc(buf, buf->buffer, uint8_t, newsize);
NT_STATUS_HAVE_NO_MEMORY(buffer_ptr);
buf->buffer = buffer_ptr;
*/
static void appendacl_handler(struct smbcli_request *req)
{
- struct composite_context *c = req->async.private;
+ struct composite_context *c = (struct composite_context *)req->async.private;
struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
/* when this handler is called, the stage indicates what
*/
static void loadfile_handler(struct smbcli_request *req)
{
- struct composite_context *c = req->async.private;
+ struct composite_context *c = (struct composite_context *)req->async.private;
struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
/* when this handler is called, the stage indicates what
*/
static void savefile_handler(struct smbcli_request *req)
{
- struct composite_context *c = req->async.private;
+ struct composite_context *c = (struct composite_context *)req->async.private;
struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
/* when this handler is called, the stage indicates what
*/
static void request_handler(struct smbcli_request *req)
{
- struct composite_context *c = req->async.private;
+ struct composite_context *c = (struct composite_context *)req->async.private;
struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
struct smbcli_session *session = req->session;
DATA_BLOB session_key = data_blob(NULL, 0);
req->recv_handler = NULL;
if (object != NULL) {
- req->object = talloc_memdup(req, object, sizeof(*object));
+ req->object = talloc_memdup(req, (void *)object, sizeof(*object));
if (req->object == NULL) {
talloc_free(req);
return NULL;
*/
static void pipe_dead(struct dcerpc_connection *c, NTSTATUS status)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
if (smb->dead) {
return;
*/
static NTSTATUS send_read_request_continue(struct dcerpc_connection *c, DATA_BLOB *blob)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
union smb_read *io;
struct smb_read_state *state;
struct smbcli_request *req;
*/
static NTSTATUS send_read_request(struct dcerpc_connection *c)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
if (smb->dead) {
return NT_STATUS_CONNECTION_DISCONNECTED;
*/
static void smb_trans_callback(struct smbcli_request *req)
{
- struct smb_trans_state *state = req->async.private;
+ struct smb_trans_state *state = (struct smb_trans_state *)req->async.private;
struct dcerpc_connection *c = state->c;
NTSTATUS status;
*/
static NTSTATUS smb_send_trans_request(struct dcerpc_connection *c, DATA_BLOB *blob)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
struct smb_trans2 *trans;
uint16_t setup[2];
struct smb_trans_state *state;
*/
static void smb_write_callback(struct smbcli_request *req)
{
- struct dcerpc_connection *c = req->async.private;
+ struct dcerpc_connection *c = (struct dcerpc_connection *)req->async.private;
if (!NT_STATUS_IS_OK(req->status)) {
DEBUG(0,("dcerpc_smb: write callback error\n"));
*/
static NTSTATUS smb_send_request(struct dcerpc_connection *c, DATA_BLOB *blob, BOOL trigger_read)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
union smb_write io;
struct smbcli_request *req;
*/
static NTSTATUS smb_shutdown_pipe(struct dcerpc_connection *c, NTSTATUS status)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
union smb_close io;
struct smbcli_request *req;
*/
static const char *smb_peer_name(struct dcerpc_connection *c)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
return smb->server_name;
}
*/
static NTSTATUS smb_session_key(struct dcerpc_connection *c, DATA_BLOB *session_key)
{
- struct smb_private *smb = c->transport.private_data;
+ struct smb_private *smb = (struct smb_private *)c->transport.private_data;
if (smb->tree->session->user_session_key.data) {
*session_key = smb->tree->session->user_session_key;
*/
static void pipe_dead(struct dcerpc_connection *c, NTSTATUS status)
{
- struct smb2_private *smb = c->transport.private_data;
+ struct smb2_private *smb = (struct smb2_private *)c->transport.private_data;
if (smb->dead) {
return;
*/
static NTSTATUS send_read_request_continue(struct dcerpc_connection *c, DATA_BLOB *blob)
{
- struct smb2_private *smb = c->transport.private_data;
+ struct smb2_private *smb = (struct smb2_private *)c->transport.private_data;
struct smb2_read io;
struct smb2_read_state *state;
struct smb2_request *req;
*/
static NTSTATUS send_read_request(struct dcerpc_connection *c)
{
- struct smb2_private *smb = c->transport.private_data;
+ struct smb2_private *smb = (struct smb2_private *)c->transport.private_data;
if (smb->dead) {
return NT_STATUS_CONNECTION_DISCONNECTED;
*/
static void smb2_write_callback(struct smb2_request *req)
{
- struct dcerpc_connection *c = req->async.private;
+ struct dcerpc_connection *c = (struct dcerpc_connection *)req->async.private;
if (!NT_STATUS_IS_OK(req->status)) {
DEBUG(0,("dcerpc_smb2: write callback error\n"));
static NTSTATUS smb2_send_request(struct dcerpc_connection *c, DATA_BLOB *blob,
BOOL trigger_read)
{
- struct smb2_private *smb = c->transport.private_data;
+ struct smb2_private *smb = (struct smb2_private *)c->transport.private_data;
struct smb2_write io;
struct smb2_request *req;
*/
static NTSTATUS smb2_shutdown_pipe(struct dcerpc_connection *c, NTSTATUS status)
{
- struct smb2_private *smb = c->transport.private_data;
+ struct smb2_private *smb = (struct smb2_private *)c->transport.private_data;
struct smb2_close io;
struct smb2_request *req;
*/
static void sock_dead(struct dcerpc_connection *p, NTSTATUS status)
{
- struct sock_private *sock = p->transport.private_data;
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
if (!sock) return;
{
struct dcerpc_connection *p = talloc_get_type(private,
struct dcerpc_connection);
- struct sock_private *sock = p->transport.private_data;
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
sock->pending_reads--;
if (sock->pending_reads == 0) {
packet_recv_disable(sock->packet);
{
struct dcerpc_connection *p = talloc_get_type(private,
struct dcerpc_connection);
- struct sock_private *sock = p->transport.private_data;
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
if (flags & EVENT_FD_WRITE) {
packet_queue_run(sock->packet);
*/
static NTSTATUS sock_send_read(struct dcerpc_connection *p)
{
- struct sock_private *sock = p->transport.private_data;
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
sock->pending_reads++;
if (sock->pending_reads == 1) {
packet_recv_enable(sock->packet);
static NTSTATUS sock_send_request(struct dcerpc_connection *p, DATA_BLOB *data,
BOOL trigger_read)
{
- struct sock_private *sock = p->transport.private_data;
+ struct sock_private *sock = (struct sock_private *)p->transport.private_data;
DATA_BLOB blob;
NTSTATUS status;
#if (_SAMBA_BUILD_ >= 4)
-static void show_pipes(void)
+_NORETURN_ static void show_pipes(void)
{
const struct ndr_interface_list *l;
printf("\nYou must specify a pipe\n");
#endif
-static void show_functions(const struct ndr_interface_table *p)
+_NORETURN_ static void show_functions(const struct ndr_interface_table *p)
{
int i;
printf("\nYou must specify a function\n");
static EjsId eid;
-static void smbscript_ejs_exception(const char *reason)
+_NORETURN_ static void smbscript_ejs_exception(const char *reason)
{
Ejs *ep = ejsPtr(eid);
ejsSetErrorMsg(eid, "%s", reason);
/* called when a task goes down */
-static void standard_terminate(struct event_context *ev, const char *reason)
+_NORETURN_ static void standard_terminate(struct event_context *ev, const char *reason)
{
DEBUG(2,("standard_terminate: reason[%s]\n",reason));
/*
die if the user selected maximum runtime is exceeded
*/
-static void max_runtime_handler(struct event_context *ev, struct timed_event *te,
+_NORETURN_ static void max_runtime_handler(struct event_context *ev, struct timed_event *te,
struct timeval t, void *private)
{
const char *binary_name = private;
if ( string_offset + len + 1 > ndr->data_size )
return NT_STATUS_INVALID_PARAMETER;
- *dest = talloc_zero_size(mem_ctx, len+1);
+ *dest = talloc_zero_array(mem_ctx, char, len+1);
pull_string(*dest, p, len+1, len, STR_ASCII);
return NT_STATUS_OK;
#include "torture/util.h"
#include "librpc/rpc/dcerpc.h"
#include "torture/rpc/rpc.h"
+#include "torture/raw/proto.h"
static struct {
const char *name;
#include "libcli/raw/libcliraw.h"
#include "libcli/libcli.h"
#include "torture/util.h"
+#include "torture/raw/proto.h"
#define BASEDIR "\\testsfileinfo"
}
}
-static void usage(poptContext pc)
+_NORETURN_ static void usage(poptContext pc)
{
struct torture_suite *o;
struct torture_suite *s;
exit(1);
}
-static void max_runtime_handler(int sig)
+_NORETURN_ static void max_runtime_handler(int sig)
{
DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
exit(1);
}
static bool wrap_test_with_testcase(struct torture_context *torture_ctx,
- struct torture_tcase *tcase,
- struct torture_test *test)
+ struct torture_tcase *tcase,
+ struct torture_test *test)
{
bool (*fn) (struct torture_context *,
- const void *tcase_data,
- const void *test_data);
+ const void *tcase_data,
+ const void *test_data);
fn = test->fn;