#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
/*
wrapper around smbcli_sock_connect()
{
if (c == NULL) return NT_STATUS_NO_MEMORY;
- while (c->state < SMBCLI_REQUEST_DONE) {
+ while (c->state < COMPOSITE_STATE_DONE) {
if (event_loop_once(c->event_ctx) != 0) {
return NT_STATUS_UNSUCCESSFUL;
}
struct timeval t, void *ptr)
{
struct composite_context *c = talloc_get_type(ptr, struct composite_context);
- c->state = SMBCLI_REQUEST_DONE;
if (c->async.fn) {
c->async.fn(c);
}
*/
void composite_trigger_done(struct composite_context *c)
{
+ c->state = COMPOSITE_STATE_DONE;
/* a zero timeout means immediate */
event_add_timed(c->event_ctx, c, timeval_zero(), composite_trigger, c);
}
/*
Unix SMB/CIFS implementation.
- SMB composite request interfaces
+ composite request interfaces
Copyright (C) Andrew Tridgell 2005
/*
this defines the structures associated with "composite"
requests. Composite requests are libcli requests that are internally
- implemented as multiple libcli/raw/ calls, but can be treated as a
+ implemented as multiple async calls, but can be treated as a
single call via these composite calls. The composite calls are
- particularly designed to be used in async applications
+ particularly designed to be used in async applications.
+ you can also stack multiple level of composite call
*/
+/*
+ a composite call moves between the following 3 states.
+*/
+enum composite_state {COMPOSITE_STATE_INIT, /* we are creating the request */
+ COMPOSITE_STATE_IN_PROGRESS, /* the request is in the outgoing socket Q */
+ COMPOSITE_STATE_DONE, /* the request is received by the caller finished */
+ COMPOSITE_STATE_ERROR}; /* a packet or transport level error has occurred */
+/* the context of one "composite" call */
struct composite_context {
/* the external state - will be queried by the caller */
- enum smbcli_request_state state;
+ enum composite_state state;
/* a private pointer for use by the composite function
implementation */
- void *private;
+ void *private_data;
/* status code when finished */
NTSTATUS status;
/* information on what to do on completion */
struct {
void (*fn)(struct composite_context *);
- void *private;
+ void *private_data;
} async;
-
- /* information about the progress */
- void (*monitor_fn)(struct monitor_msg *);
-};
-
-
-/*
- a composite open/read(s)/close request that loads a whole file
- into memory. Used as a demo of the composite system.
-*/
-struct smb_composite_loadfile {
- struct {
- const char *fname;
- } in;
- struct {
- uint8_t *data;
- uint32_t size;
- } out;
-};
-
-struct smb_composite_fetchfile {
- struct {
- const char *dest_host;
- int port;
- const char *called_name;
- const char *service;
- const char *service_type;
- struct cli_credentials *credentials;
- const char *workgroup;
- const char *filename;
- } in;
- struct {
- uint8_t *data;
- uint32_t size;
- } out;
-};
-
-/*
- a composite open/write(s)/close request that saves a whole file from
- memory. Used as a demo of the composite system.
-*/
-struct smb_composite_savefile {
- struct {
- const char *fname;
- uint8_t *data;
- uint32_t size;
- } in;
-};
-
-
-/*
- a composite request for a full connection to a remote server. Includes
-
- - socket establishment
- - session request
- - negprot
- - session setup
- - tree connect
-*/
-struct smb_composite_connect {
- struct {
- const char *dest_host;
- int port;
- const char *called_name;
- const char *service;
- const char *service_type;
- struct cli_credentials *credentials;
- const char *workgroup;
- } in;
- struct {
- struct smbcli_tree *tree;
- } out;
-};
-
-
-/*
- generic session setup interface that takes care of which
- session setup varient to use
-*/
-struct smb_composite_sesssetup {
- struct {
- uint32_t sesskey;
- uint32_t capabilities;
- struct cli_credentials *credentials;
- const char *workgroup;
- } in;
- struct {
- uint16_t vuid;
- } out;
-};
-
-/*
- query file system info
-*/
-struct smb_composite_fsinfo {
- struct {
- const char *dest_host;
- int port;
- const char *called_name;
- const char *service;
- const char *service_type;
- struct cli_credentials *credentials;
- const char *workgroup;
- enum smb_fsinfo_level level;
- } in;
-
- struct {
- union smb_fsinfo *fsinfo;
- } out;
-};
-
-/*
- composite call for appending new acl to the file's security descriptor and get
- new full acl
-*/
-
-struct smb_composite_appendacl {
- struct {
- const char *fname;
-
- const struct security_descriptor *sd;
- } in;
-
- struct {
- struct security_descriptor *sd;
- } out;
};
+++ /dev/null
-/*
- Unix SMB/CIFS implementation.
-
- Definitions of composite function monitoring messages.
-
- Copyright (C) Rafal Szczesniak 2005
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-/*
- * Monitor structure and message types definitions. Composite function monitoring
- * allows client application to be notified on function progress. This enables
- * eg. gui client to display progress bars, status messages, etc.
- */
-
-
-#define rpc_create_user (0x00000001) /* userman.h */
-#define rpc_open_user (0x00000002) /* userinfo.h */
-#define rpc_query_user (0x00000003) /* userinfo.h */
-#define rpc_close_user (0x00000004) /* userinfo.h */
-#define rpc_lookup_name (0x00000005) /* userman.h */
-#define rpc_delete_user (0x00000006) /* userman.h */
-
-
-struct monitor_msg {
- uint32_t type;
- void *data;
- size_t data_size;
-};
ADD_OBJ_FILES = libcli/util/clilsa.o
REQUIRED_SUBSYSTEMS = RPC_NDR_LSA
-[SUBSYSTEM::LIBCLI_COMPOSITE_BASE]
+[SUBSYSTEM::LIBCLI_COMPOSITE]
ADD_OBJ_FILES = \
libcli/composite/composite.o
REQUIRED_SUBSYSTEMS = LIBEVENTS
-[SUBSYSTEM::LIBCLI_COMPOSITE]
+[SUBSYSTEM::LIBCLI_SMB_COMPOSITE]
ADD_OBJ_FILES = \
- libcli/composite/loadfile.o \
- libcli/composite/savefile.o \
- libcli/composite/connect.o \
- libcli/composite/sesssetup.o \
- libcli/composite/fetchfile.o \
- libcli/composite/appendacl.o \
- libcli/composite/fsinfo.o
-REQUIRED_SUBSYSTEMS = LIBCLI_COMPOSITE_BASE
+ libcli/smb_composite/loadfile.o \
+ libcli/smb_composite/savefile.o \
+ libcli/smb_composite/connect.o \
+ libcli/smb_composite/sesssetup.o \
+ libcli/smb_composite/fetchfile.o \
+ libcli/smb_composite/appendacl.o \
+ libcli/smb_composite/fsinfo.o
+REQUIRED_SUBSYSTEMS = LIBCLI_COMPOSITE
[SUBSYSTEM::LIBCLI_NBT]
ADD_OBJ_FILES = \
libcli/nbt/nameregister.o \
libcli/nbt/namerefresh.o \
libcli/nbt/namerelease.o
-REQUIRED_SUBSYSTEMS = NDR_RAW NDR_NBT SOCKET LIBCLI_COMPOSITE_BASE LIBEVENTS \
+REQUIRED_SUBSYSTEMS = NDR_RAW NDR_NBT SOCKET LIBCLI_COMPOSITE LIBEVENTS \
LIB_SECURITY_NDR
[SUBSYSTEM::LIBCLI_DGRAM]
[SUBSYSTEM::LIBCLI]
REQUIRED_SUBSYSTEMS = LIBCLI_RAW LIBCLI_UTILS LIBCLI_AUTH \
- LIBCLI_COMPOSITE LIBCLI_NBT LIB_SECURITY LIBCLI_RESOLVE \
+ LIBCLI_SMB_COMPOSITE LIBCLI_NBT LIB_SECURITY LIBCLI_RESOLVE \
LIBCLI_DGRAM
[SUBSYSTEM::LIBSMB]
#include "includes.h"
#include "libcli/nbt/libnbt.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
/*
{
struct composite_context *c = talloc_get_type(req->async.private,
struct composite_context);
- struct refresh_wins_state *state = talloc_get_type(c->private,
+ struct refresh_wins_state *state = talloc_get_type(c->private_data,
struct refresh_wins_state);
NTSTATUS status;
state->wins_servers++;
state->address_idx = 0;
if (state->wins_servers[0] == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
goto done;
}
state->io->in.address = state->addresses[0];
state->req = nbt_name_refresh_send(state->nbtsock, state->io);
if (state->req == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_refresh_wins_handler;
state->req->async.private = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
} else {
if (state->io->out.rcode == 0 &&
state->io->in.address = state->addresses[++(state->address_idx)];
state->req = nbt_name_refresh_send(state->nbtsock, state->io);
if (state->req == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_refresh_wins_handler;
state->req->async.private = c;
}
} else {
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
c->status = NT_STATUS_OK;
}
}
done:
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
state->req->async.fn = name_refresh_wins_handler;
state->req->async.private = c;
- c->private = state;
- c->state = SMBCLI_REQUEST_SEND;
- c->event_ctx = nbtsock->event_ctx;
+ c->private_data = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->event_ctx = nbtsock->event_ctx;
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
struct refresh_wins_state *state =
- talloc_get_type(c->private, struct refresh_wins_state);
+ talloc_get_type(c->private_data, struct refresh_wins_state);
io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
io->out.rcode = state->io->out.rcode;
}
#include "includes.h"
#include "libcli/nbt/libnbt.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
/*
static void name_register_bcast_handler(struct nbt_name_request *req)
{
struct composite_context *c = talloc_get_type(req->async.private, struct composite_context);
- struct register_bcast_state *state = talloc_get_type(c->private, struct register_bcast_state);
+ struct register_bcast_state *state = talloc_get_type(c->private_data, struct register_bcast_state);
NTSTATUS status;
status = nbt_name_register_recv(state->req, state, state->io);
if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
if (state->io->in.register_demand == True) {
/* all done */
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
c->status = NT_STATUS_OK;
goto done;
}
state->io->in.retries = 0;
state->req = nbt_name_register_send(state->nbtsock, state->io);
if (state->req == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_bcast_handler;
state->req->async.private = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
} else {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_CONFLICTING_ADDRESSES;
DEBUG(3,("Name registration conflict from %s for %s with ip %s - rcode %d\n",
state->io->out.reply_from,
}
done:
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
the async send call for a 4 stage name registration
*/
struct composite_context *nbt_name_register_bcast_send(struct nbt_name_socket *nbtsock,
- struct nbt_name_register_bcast *io)
+ struct nbt_name_register_bcast *io)
{
struct composite_context *c;
struct register_bcast_state *state;
state->req->async.fn = name_register_bcast_handler;
state->req->async.private = c;
- c->private = state;
- c->state = SMBCLI_REQUEST_SEND;
- c->event_ctx = nbtsock->event_ctx;
+ c->private_data = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->event_ctx = nbtsock->event_ctx;
return c;
{
struct composite_context *c = talloc_get_type(req->async.private,
struct composite_context);
- struct register_wins_state *state = talloc_get_type(c->private,
+ struct register_wins_state *state = talloc_get_type(c->private_data,
struct register_wins_state);
NTSTATUS status;
state->wins_servers++;
state->address_idx = 0;
if (state->wins_servers[0] == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
goto done;
}
state->io->in.address = state->addresses[0];
state->req = nbt_name_register_send(state->nbtsock, state->io);
if (state->req == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_wins_handler;
state->req->async.private = c;
}
} else if (!NT_STATUS_IS_OK(status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
} else {
if (state->io->out.rcode == 0 &&
state->io->in.address = state->addresses[++(state->address_idx)];
state->req = nbt_name_register_send(state->nbtsock, state->io);
if (state->req == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
} else {
state->req->async.fn = name_register_wins_handler;
state->req->async.private = c;
}
} else {
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
c->status = NT_STATUS_OK;
}
}
done:
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
state->req->async.fn = name_register_wins_handler;
state->req->async.private = c;
- c->private = state;
- c->state = SMBCLI_REQUEST_SEND;
- c->event_ctx = nbtsock->event_ctx;
+ c->private_data = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->event_ctx = nbtsock->event_ctx;
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
struct register_wins_state *state =
- talloc_get_type(c->private, struct register_wins_state);
+ talloc_get_type(c->private_data, struct register_wins_state);
io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
io->out.rcode = state->io->out.rcode;
}
has either completed the connect() or has returned an error
*/
static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_event *fde,
- uint16_t flags, void *private)
+ uint16_t flags, void *private_data)
{
- struct composite_context *c = talloc_get_type(private, struct composite_context);
- struct clisocket_connect *conn = talloc_get_type(c->private, struct clisocket_connect);
+ struct composite_context *c = talloc_get_type(private_data, struct composite_context);
+ struct clisocket_connect *conn = talloc_get_type(c->private_data, struct clisocket_connect);
int i;
c->status = socket_connect_complete(conn->sock->sock, 0);
if (NT_STATUS_IS_OK(c->status)) {
socket_set_option(conn->sock->sock, lp_socket_options(), NULL);
conn->sock->hostname = talloc_strdup(conn->sock, conn->dest_hostname);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
if (c->async.fn) {
c->async.fn(c);
}
}
}
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
if (c->async.fn) {
c->async.fn(c);
}
conn->dest_hostname = talloc_strdup(c, host_name);
if (conn->dest_hostname == NULL) goto failed;
- c->private = conn;
- c->state = SMBCLI_REQUEST_SEND;
+ c->private_data = conn;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
/* startup the connect process for each port in turn until one
succeeds or tells us that it is pending */
}
}
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
return c;
failed:
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#define SETUP_REQUEST_TREE(cmd, wct, buflen) do { \
req = smbcli_request_setup(tree, cmd, wct, buflen); \
*/
static void run_child(struct composite_context *c, int fd)
{
- struct host_state *state = talloc_get_type(c->private, struct host_state);
+ struct host_state *state = talloc_get_type(c->private_data, struct host_state);
struct ipv4_addr ip;
const char *address;
handle a read event on the pipe
*/
static void pipe_handler(struct event_context *ev, struct fd_event *fde,
- uint16_t flags, void *private)
+ uint16_t flags, void *private_data)
{
- struct composite_context *c = talloc_get_type(private, struct composite_context);
- struct host_state *state = talloc_get_type(c->private, struct host_state);
+ struct composite_context *c = talloc_get_type(private_data, struct composite_context);
+ struct host_state *state = talloc_get_type(c->private_data, struct host_state);
char address[128];
int ret;
if (state->reply_addr == NULL) goto failed;
c->status = NT_STATUS_OK;
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
if (c->async.fn) {
c->async.fn(c);
}
failed:
c->status = NT_STATUS_BAD_NETWORK_NAME;
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
if (c->async.fn) {
c->async.fn(c);
}
status = nbt_name_dup(state, name, &state->name);
if (!NT_STATUS_IS_OK(status)) goto failed;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data = state;
c->event_ctx = talloc_reference(c, event_ctx);
/* setup a pipe to chat to our child */
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct host_state *state = talloc_get_type(c->private, struct host_state);
+ struct host_state *state = talloc_get_type(c->private_data, struct host_state);
*reply_addr = talloc_steal(mem_ctx, state->reply_addr);
}
static void nbtlist_handler(struct nbt_name_request *req)
{
struct composite_context *c = talloc_get_type(req->async.private,
- struct composite_context);
- struct nbtlist_state *state = talloc_get_type(c->private, struct nbtlist_state);
+ struct composite_context);
+ struct nbtlist_state *state = talloc_get_type(c->private_data, struct nbtlist_state);
int i;
for (i=0;i<state->num_queries;i++) {
if (i == state->num_queries) {
/* not for us?! */
c->status = NT_STATUS_INTERNAL_ERROR;
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
goto done;
- }
+ }
c->status = nbt_name_query_recv(req, state, &state->io_queries[i]);
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
} else {
if (state->io_queries[i].out.num_addrs < 1) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
} else {
struct nbt_name_query *q = &state->io_queries[i];
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
/* favor a local address if possible */
state->reply_addr = NULL;
for (i=0;i<q->out.num_addrs;i++) {
state->queries[i]->async.private = c;
}
- c->state = SMBCLI_REQUEST_SEND;
- c->private = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data = state;
c->event_ctx = talloc_reference(c, state->nbtsock->event_ctx);
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct nbtlist_state *state = talloc_get_type(c->private, struct nbtlist_state);
+ struct nbtlist_state *state = talloc_get_type(c->private_data, struct nbtlist_state);
*reply_addr = talloc_steal(mem_ctx, state->reply_addr);
}
struct resolve_state {
struct nbt_name name;
const char **methods;
- struct composite_context *req;
+ struct composite_context *creq;
const char *reply_addr;
};
/*
handle completion of one name resolve method
*/
-static void resolve_handler(struct composite_context *req)
+static void resolve_handler(struct composite_context *creq)
{
- struct composite_context *c = req->async.private;
- struct resolve_state *state = talloc_get_type(c->private, struct resolve_state);
+ struct composite_context *c = creq->async.private_data;
+ struct resolve_state *state = talloc_get_type(c->private_data, struct resolve_state);
const struct resolve_method *method = find_method(state->methods[0]);
- c->status = method->recv_fn(req, state, &state->reply_addr);
+ c->status = method->recv_fn(creq, state, &state->reply_addr);
if (!NT_STATUS_IS_OK(c->status)) {
state->methods++;
- state->req = setup_next_method(c);
- if (state->req != NULL) {
+ state->creq = setup_next_method(c);
+ if (state->creq != NULL) {
return;
}
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
} else {
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
}
if (c->async.fn) {
c->async.fn(c);
static struct composite_context *setup_next_method(struct composite_context *c)
{
- struct resolve_state *state = talloc_get_type(c->private, struct resolve_state);
- struct composite_context *req = NULL;
+ struct resolve_state *state = talloc_get_type(c->private_data, struct resolve_state);
+ struct composite_context *creq = NULL;
do {
const struct resolve_method *method = find_method(state->methods[0]);
if (method) {
- req = method->send_fn(&state->name, c->event_ctx);
+ creq = method->send_fn(&state->name, c->event_ctx);
}
- if (req == NULL && state->methods[0]) state->methods++;
- } while (!req && state->methods[0]);
+ if (creq == NULL && state->methods[0]) state->methods++;
+ } while (!creq && state->methods[0]);
- if (req) {
- req->async.fn = resolve_handler;
- req->async.private = c;
+ if (creq) {
+ creq->async.fn = resolve_handler;
+ creq->async.private_data = c;
}
- return req;
+ return creq;
}
/*
state->methods = str_list_copy(state, methods);
if (state->methods == NULL) goto failed;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data = state;
if (event_ctx == NULL) {
c->event_ctx = event_context_init(c);
if (c->event_ctx == NULL) goto failed;
return c;
}
- state->req = setup_next_method(c);
- if (state->req == NULL) goto failed;
+ state->creq = setup_next_method(c);
+ if (state->creq == NULL) goto failed;
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct resolve_state *state = talloc_get_type(c->private, struct resolve_state);
+ struct resolve_state *state = talloc_get_type(c->private_data, struct resolve_state);
*reply_addr = talloc_steal(mem_ctx, state->reply_addr);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "librpc/gen_ndr/ndr_security.h"
/* the stages of this call */
static NTSTATUS appendacl_open(struct composite_context *c,
struct smb_composite_appendacl *io)
{
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
static NTSTATUS appendacl_get(struct composite_context *c,
struct smb_composite_appendacl *io)
{
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
struct smbcli_tree *tree = state->req->tree;
int i;
NTSTATUS status;
static NTSTATUS appendacl_set(struct composite_context *c,
struct smb_composite_appendacl *io)
{
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
static NTSTATUS appendacl_getagain(struct composite_context *c,
struct smb_composite_appendacl *io)
{
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
struct smbcli_tree *tree = state->req->tree;
union smb_close *io_close;
NTSTATUS status;
static NTSTATUS appendacl_close(struct composite_context *c,
struct smb_composite_appendacl *io)
{
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
NTSTATUS status;
status = smbcli_request_simple_recv(state->req);
NT_STATUS_NOT_OK_RETURN(status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void appendacl_handler(struct smbcli_request *req)
{
struct composite_context *c = req->async.private;
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
/* when this handler is called, the stage indicates what
call has just finished */
/* We should get here if c->state >= SMBCLI_REQUEST_DONE */
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
state->io = io;
- c->private = state;
- c->state = SMBCLI_REQUEST_SEND;
+ c->private_data = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = tree->session->transport->socket->event.ctx;
/* setup structures for opening file */
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct appendacl_state *state = talloc_get_type(c->private, struct appendacl_state);
+ struct appendacl_state *state = talloc_get_type(c->private_data, struct appendacl_state);
state->io->out.sd = security_descriptor_copy (mem_ctx, state->io->out.sd);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
/* the stages of this call */
enum connect_stage {CONNECT_RESOLVE,
static NTSTATUS connect_send_negprot(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
state->req = smb_raw_negotiate_send(state->transport, lp_maxprotocol());
NT_STATUS_HAVE_NO_MEMORY(state->req);
static NTSTATUS connect_tcon(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
status = smb_raw_tcon_recv(state->req, c, state->io_tcon);
}
/* all done! */
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static NTSTATUS connect_session_setup(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
status = smb_composite_sesssetup_recv(state->creq);
static NTSTATUS connect_negprot(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
status = smb_raw_negotiate_recv(state->req);
state->creq = smb_composite_sesssetup_send(state->session, state->io_setup);
NT_STATUS_HAVE_NO_MEMORY(state->creq);
- if (state->creq->state == SMBCLI_REQUEST_ERROR) {
+ if (state->creq->state == COMPOSITE_STATE_ERROR) {
return state->creq->status;
}
state->creq->async.fn = composite_handler;
- state->creq->async.private = c;
+ state->creq->async.private_data = c;
state->stage = CONNECT_SESSION_SETUP;
return NT_STATUS_OK;
static NTSTATUS connect_session_request(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
status = smbcli_transport_connect_recv(state->req);
static NTSTATUS connect_socket(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
struct nbt_name calling, called;
static NTSTATUS connect_resolve(struct composite_context *c,
struct smb_composite_connect *io)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
NTSTATUS status;
const char *address;
NT_STATUS_HAVE_NO_MEMORY(state->creq);
state->stage = CONNECT_SOCKET;
- state->creq->async.private = c;
+ state->creq->async.private_data = c;
state->creq->async.fn = composite_handler;
return NT_STATUS_OK;
*/
static void state_handler(struct composite_context *c)
{
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
switch (state->stage) {
case CONNECT_RESOLVE:
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
/*
handler for completion of a smbcli_composite sub-request
*/
-static void composite_handler(struct composite_context *req)
+static void composite_handler(struct composite_context *creq)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(creq->async.private_data,
struct composite_context);
state_handler(c);
}
state->io = io;
- c->state = SMBCLI_REQUEST_SEND;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = talloc_reference(c, state->sock->event.ctx);
- c->private = state;
+ c->private_data = state;
state->stage = CONNECT_RESOLVE;
make_nbt_name_server(&name, io->in.dest_host);
state->creq = resolve_name_send(&name, c->event_ctx, lp_name_resolve_order());
if (state->creq == NULL) goto failed;
- state->creq->async.private = c;
+ state->creq->async.private_data = c;
state->creq->async.fn = composite_handler;
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct connect_state *state = talloc_get_type(c->private, struct connect_state);
+ struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
talloc_steal(mem_ctx, state->io->out.tree);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
enum fetchfile_stage {FETCHFILE_CONNECT,
FETCHFILE_READ};
struct fetchfile_state {
enum fetchfile_stage stage;
struct smb_composite_fetchfile *io;
- struct composite_context *req;
+ struct composite_context *creq;
struct smb_composite_connect *connect;
struct smb_composite_loadfile *loadfile;
};
{
NTSTATUS status;
struct fetchfile_state *state;
- state = talloc_get_type(c->private, struct fetchfile_state);
+ state = talloc_get_type(c->private_data, struct fetchfile_state);
- status = smb_composite_connect_recv(state->req, c);
+ status = smb_composite_connect_recv(state->creq, c);
NT_STATUS_NOT_OK_RETURN(status);
state->loadfile = talloc(state, struct smb_composite_loadfile);
state->loadfile->in.fname = io->in.filename;
- state->req = smb_composite_loadfile_send(state->connect->out.tree,
+ state->creq = smb_composite_loadfile_send(state->connect->out.tree,
state->loadfile);
- NT_STATUS_HAVE_NO_MEMORY(state->req);
+ NT_STATUS_HAVE_NO_MEMORY(state->creq);
- state->req->async.private = c;
- state->req->async.fn = fetchfile_composite_handler;
+ state->creq->async.private_data = c;
+ state->creq->async.fn = fetchfile_composite_handler;
state->stage = FETCHFILE_READ;
- c->event_ctx = talloc_reference(c, state->req->event_ctx);
+ c->event_ctx = talloc_reference(c, state->creq->event_ctx);
return NT_STATUS_OK;
}
{
NTSTATUS status;
struct fetchfile_state *state;
- state = talloc_get_type(c->private, struct fetchfile_state);
+ state = talloc_get_type(c->private_data, struct fetchfile_state);
- status = smb_composite_loadfile_recv(state->req, NULL);
+ status = smb_composite_loadfile_recv(state->creq, NULL);
NT_STATUS_NOT_OK_RETURN(status);
io->out.data = state->loadfile->out.data;
io->out.size = state->loadfile->out.size;
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
if (c->async.fn)
c->async.fn(c);
struct fetchfile_state *state;
NTSTATUS status;
- state = talloc_get_type(c->private, struct fetchfile_state);
+ state = talloc_get_type(c->private_data, struct fetchfile_state);
/* when this handler is called, the stage indicates what
call has just finished */
if (!NT_STATUS_IS_OK(status)) {
c->status = status;
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
if (c->async.fn) {
c->async.fn(c);
}
}
}
-static void fetchfile_composite_handler(struct composite_context *req)
+static void fetchfile_composite_handler(struct composite_context *creq)
{
- struct composite_context *c = talloc_get_type(req->async.private,
- struct composite_context);
+ struct composite_context *c = talloc_get_type(creq->async.private_data,
+ struct composite_context);
fetchfile_state_handler(c);
}
struct composite_context *smb_composite_fetchfile_send(struct smb_composite_fetchfile *io,
- struct event_context *event_ctx)
+ struct event_context *event_ctx)
{
struct composite_context *c;
struct fetchfile_state *state;
state->connect->in.credentials = io->in.credentials;
state->connect->in.workgroup = io->in.workgroup;
- state->req = smb_composite_connect_send(state->connect, event_ctx);
- if (state->req == NULL) goto failed;
+ state->creq = smb_composite_connect_send(state->connect, event_ctx);
+ if (state->creq == NULL) goto failed;
- state->req->async.private = c;
- state->req->async.fn = fetchfile_composite_handler;
+ state->creq->async.private_data = c;
+ state->creq->async.fn = fetchfile_composite_handler;
- c->state = SMBCLI_REQUEST_SEND;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
state->stage = FETCHFILE_CONNECT;
- c->event_ctx = talloc_reference(c, state->req->event_ctx);
- c->private = state;
+ c->event_ctx = talloc_reference(c, state->creq->event_ctx);
+ c->private_data = state;
return c;
failed:
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct fetchfile_state *state = talloc_get_type(c->private, struct fetchfile_state);
+ struct fetchfile_state *state = talloc_get_type(c->private_data, struct fetchfile_state);
talloc_steal(mem_ctx, state->io->out.data);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "librpc/gen_ndr/ndr_security.h"
/* the stages of this call */
{
NTSTATUS status;
struct fsinfo_state *state;
- state = talloc_get_type(c->private, struct fsinfo_state);
+ state = talloc_get_type(c->private_data, struct fsinfo_state);
status = smb_composite_connect_recv(state->creq, c);
NT_STATUS_NOT_OK_RETURN(status);
{
NTSTATUS status;
struct fsinfo_state *state;
- state = talloc_get_type(c->private, struct fsinfo_state);
+ state = talloc_get_type(c->private_data, struct fsinfo_state);
status = smb_raw_fsinfo_recv(state->req, state, state->fsinfo);
NT_STATUS_NOT_OK_RETURN(status);
state->io->out.fsinfo = state->fsinfo;
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
if (c->async.fn)
c->async.fn(c);
/*
handler for completion of a sub-request in fsinfo
*/
-static void fsinfo_state_handler(struct composite_context *req)
+static void fsinfo_state_handler(struct composite_context *creq)
{
- struct fsinfo_state *state = talloc_get_type(req->private, struct fsinfo_state);
+ struct fsinfo_state *state = talloc_get_type(creq->private_data, struct fsinfo_state);
/* when this handler is called, the stage indicates what
call has just finished */
switch (state->stage) {
case FSINFO_CONNECT:
- req->status = fsinfo_connect(req, state->io);
+ creq->status = fsinfo_connect(creq, state->io);
break;
case FSINFO_QUERY:
- req->status = fsinfo_query(req, state->io);
+ creq->status = fsinfo_query(creq, state->io);
break;
}
- if (!NT_STATUS_IS_OK(req->status)) {
- req->state = SMBCLI_REQUEST_ERROR;
+ if (!NT_STATUS_IS_OK(creq->status)) {
+ creq->state = COMPOSITE_STATE_ERROR;
}
- if (req->state >= SMBCLI_REQUEST_DONE && req->async.fn) {
- req->async.fn(req);
+ if (creq->state >= COMPOSITE_STATE_DONE && creq->async.fn) {
+ creq->async.fn(creq);
}
}
fsinfo_state_handler(c);
}
-static void fsinfo_composite_handler(struct composite_context *req)
+static void fsinfo_composite_handler(struct composite_context *creq)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(creq->async.private_data,
struct composite_context);
fsinfo_state_handler(c);
}
state->connect->in.credentials = io->in.credentials;
state->connect->in.workgroup = io->in.workgroup;
- c->state = SMBCLI_REQUEST_SEND;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
state->stage = FSINFO_CONNECT;
c->event_ctx = talloc_reference(c, tree->session->transport->socket->event.ctx);
- c->private = state;
+ c->private_data = state;
state->creq = smb_composite_connect_send(state->connect, c->event_ctx);
if (state->creq == NULL) goto failed;
- state->creq->async.private = c;
+ state->creq->async.private_data = c;
state->creq->async.fn = fsinfo_composite_handler;
return c;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct fsinfo_state *state = talloc_get_type(c->private, struct fsinfo_state);
+ struct fsinfo_state *state = talloc_get_type(c->private_data, struct fsinfo_state);
talloc_steal(mem_ctx, state->io->out.fsinfo);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "librpc/gen_ndr/ndr_security.h"
/* the stages of this call */
static NTSTATUS setup_close(struct composite_context *c,
struct smbcli_tree *tree, uint16_t fnum)
{
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
union smb_close *io_close;
/* nothing to read, setup the close */
static NTSTATUS loadfile_open(struct composite_context *c,
struct smb_composite_loadfile *io)
{
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
static NTSTATUS loadfile_read(struct composite_context *c,
struct smb_composite_loadfile *io)
{
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
static NTSTATUS loadfile_close(struct composite_context *c,
struct smb_composite_loadfile *io)
{
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
NTSTATUS status;
status = smbcli_request_simple_recv(state->req);
NT_STATUS_NOT_OK_RETURN(status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void loadfile_handler(struct smbcli_request *req)
{
struct composite_context *c = req->async.private;
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
/* when this handler is called, the stage indicates what
call has just finished */
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
state->io = io;
- c->private = state;
- c->state = SMBCLI_REQUEST_SEND;
+ c->private_data = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = tree->session->transport->socket->event.ctx;
/* setup for the open */
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct loadfile_state *state = talloc_get_type(c->private, struct loadfile_state);
+ struct loadfile_state *state = talloc_get_type(c->private_data, struct loadfile_state);
talloc_steal(mem_ctx, state->io->out.data);
}
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "librpc/gen_ndr/ndr_security.h"
/* the stages of this call */
static NTSTATUS setup_close(struct composite_context *c,
struct smbcli_tree *tree, uint16_t fnum)
{
- struct savefile_state *state = talloc_get_type(c->private, struct savefile_state);
+ struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
union smb_close *io_close;
/* nothing to write, setup the close */
static NTSTATUS savefile_open(struct composite_context *c,
struct smb_composite_savefile *io)
{
- struct savefile_state *state = talloc_get_type(c->private, struct savefile_state);
+ struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
union smb_write *io_write;
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
static NTSTATUS savefile_write(struct composite_context *c,
struct smb_composite_savefile *io)
{
- struct savefile_state *state = talloc_get_type(c->private, struct savefile_state);
+ struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
struct smbcli_tree *tree = state->req->tree;
NTSTATUS status;
uint32_t max_xmit = tree->session->transport->negotiate.max_xmit;
static NTSTATUS savefile_close(struct composite_context *c,
struct smb_composite_savefile *io)
{
- struct savefile_state *state = talloc_get_type(c->private, struct savefile_state);
+ struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
NTSTATUS status;
status = smbcli_request_simple_recv(state->req);
return NT_STATUS_DISK_FULL;
}
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void savefile_handler(struct smbcli_request *req)
{
struct composite_context *c = req->async.private;
- struct savefile_state *state = talloc_get_type(c->private, struct savefile_state);
+ struct savefile_state *state = talloc_get_type(c->private_data, struct savefile_state);
/* when this handler is called, the stage indicates what
call has just finished */
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
followed by a close
*/
struct composite_context *smb_composite_savefile_send(struct smbcli_tree *tree,
- struct smb_composite_savefile *io)
+ struct smb_composite_savefile *io)
{
struct composite_context *c;
struct savefile_state *state;
c = talloc_zero(tree, struct composite_context);
if (c == NULL) goto failed;
- c->state = SMBCLI_REQUEST_SEND;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = tree->session->transport->socket->event.ctx;
state = talloc(c, struct savefile_state);
/* setup the callback handler */
state->req->async.fn = savefile_handler;
state->req->async.private = c;
- c->private = state;
+ c->private_data = state;
return c;
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "auth/auth.h"
#include "version.h"
static void request_handler(struct smbcli_request *req)
{
struct composite_context *c = req->async.private;
- struct sesssetup_state *state = talloc_get_type(c->private, struct sesssetup_state);
+ 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);
DATA_BLOB null_data_blob = data_blob(NULL, 0);
}
if (NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
} else {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
if (c->async.fn) {
c->async.fn(c);
struct smb_composite_sesssetup *io,
struct smbcli_request **req)
{
- struct sesssetup_state *state = talloc_get_type(c->private, struct sesssetup_state);
+ struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
const struct samr_Password *nt_hash = cli_credentials_get_nt_hash(io->in.credentials, state);
const char *password = cli_credentials_get_password(io->in.credentials);
struct smb_composite_sesssetup *io,
struct smbcli_request **req)
{
- struct sesssetup_state *state = talloc_get_type(c->private, struct sesssetup_state);
+ struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
const char *password = cli_credentials_get_password(io->in.credentials);
state->setup.old.level = RAW_SESSSETUP_OLD;
struct smb_composite_sesssetup *io,
struct smbcli_request **req)
{
- struct sesssetup_state *state = talloc_get_type(c->private, struct sesssetup_state);
+ struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
NTSTATUS status, session_key_err;
DATA_BLOB session_key = data_blob(NULL, 0);
DATA_BLOB null_data_blob = data_blob(NULL, 0);
state = talloc(c, struct sesssetup_state);
if (state == NULL) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = NT_STATUS_NO_MEMORY;
}
state->io = io;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = state;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data = state;
c->event_ctx = session->transport->socket->event.ctx;
/* no session setup at all in earliest protocol varients */
if (session->transport->negotiate.protocol < PROTOCOL_LANMAN1) {
ZERO_STRUCT(io->out);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return c;
}
return c;
}
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
c->status = status;
return c;
}
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+
+ SMB composite request interfaces
+
+ Copyright (C) Andrew Tridgell 2005
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ this defines the structures associated with "composite"
+ requests. Composite requests are libcli requests that are internally
+ implemented as multiple libcli/raw/ calls, but can be treated as a
+ single call via these composite calls. The composite calls are
+ particularly designed to be used in async applications
+*/
+
+
+/*
+ a composite open/read(s)/close request that loads a whole file
+ into memory. Used as a demo of the composite system.
+*/
+struct smb_composite_loadfile {
+ struct {
+ const char *fname;
+ } in;
+ struct {
+ uint8_t *data;
+ uint32_t size;
+ } out;
+};
+
+struct smb_composite_fetchfile {
+ struct {
+ const char *dest_host;
+ int port;
+ const char *called_name;
+ const char *service;
+ const char *service_type;
+ struct cli_credentials *credentials;
+ const char *workgroup;
+ const char *filename;
+ } in;
+ struct {
+ uint8_t *data;
+ uint32_t size;
+ } out;
+};
+
+/*
+ a composite open/write(s)/close request that saves a whole file from
+ memory. Used as a demo of the composite system.
+*/
+struct smb_composite_savefile {
+ struct {
+ const char *fname;
+ uint8_t *data;
+ uint32_t size;
+ } in;
+};
+
+
+/*
+ a composite request for a full connection to a remote server. Includes
+
+ - socket establishment
+ - session request
+ - negprot
+ - session setup
+ - tree connect
+*/
+struct smb_composite_connect {
+ struct {
+ const char *dest_host;
+ int port;
+ const char *called_name;
+ const char *service;
+ const char *service_type;
+ struct cli_credentials *credentials;
+ const char *workgroup;
+ } in;
+ struct {
+ struct smbcli_tree *tree;
+ } out;
+};
+
+
+/*
+ generic session setup interface that takes care of which
+ session setup varient to use
+*/
+struct smb_composite_sesssetup {
+ struct {
+ uint32_t sesskey;
+ uint32_t capabilities;
+ struct cli_credentials *credentials;
+ const char *workgroup;
+ } in;
+ struct {
+ uint16_t vuid;
+ } out;
+};
+
+/*
+ query file system info
+*/
+struct smb_composite_fsinfo {
+ struct {
+ const char *dest_host;
+ int port;
+ const char *called_name;
+ const char *service;
+ const char *service_type;
+ struct cli_credentials *credentials;
+ const char *workgroup;
+ enum smb_fsinfo_level level;
+ } in;
+
+ struct {
+ union smb_fsinfo *fsinfo;
+ } out;
+};
+
+/*
+ composite call for appending new acl to the file's security descriptor and get
+ new full acl
+*/
+
+struct smb_composite_appendacl {
+ struct {
+ const char *fname;
+
+ const struct security_descriptor *sd;
+ } in;
+
+ struct {
+ struct security_descriptor *sd;
+ } out;
+};
#include "librpc/gen_ndr/ndr_samr.h"
+/*
+ * Monitor structure and message types definitions. Composite function monitoring
+ * allows client application to be notified on function progress. This enables
+ * eg. gui client to display progress bars, status messages, etc.
+ */
+
+
+#define rpc_create_user (0x00000001) /* userman.h */
+#define rpc_open_user (0x00000002) /* userinfo.h */
+#define rpc_query_user (0x00000003) /* userinfo.h */
+#define rpc_close_user (0x00000004) /* userinfo.h */
+#define rpc_lookup_name (0x00000005) /* userman.h */
+#define rpc_delete_user (0x00000006) /* userman.h */
+
+struct monitor_msg {
+ uint32_t type;
+ void *data;
+ size_t data_size;
+};
struct libnet_rpc_userinfo {
struct {
*/
#include "includes.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
-#include "libcli/composite/monitor.h"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
c->status = dcerpc_ndr_request_recv(s->req);
NT_STATUS_NOT_OK_RETURN(c->status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void domain_open_handler(struct rpc_request *req)
{
struct composite_context *c = req->async.private;
- struct domain_open_state *s = talloc_get_type(c->private, struct domain_open_state);
- struct monitor_msg msg;
+ struct domain_open_state *s = talloc_get_type(c->private_data, struct domain_open_state);
/* Stages of the call */
switch (s->stage) {
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
- }
-
- if (c->monitor_fn) {
- c->monitor_fn(&msg);
+ c->state = COMPOSITE_STATE_ERROR;
}
}
s = talloc_zero(c, struct domain_open_state);
if (s == NULL) goto failure;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = s;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data= s;
c->event_ctx = dcerpc_event_context(p);
- c->monitor_fn = monitor;
s->pipe = p;
s->access_mask = io->in.access_mask;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status) && io) {
- s = talloc_get_type(c->private, struct domain_open_state);
+ s = talloc_get_type(c->private_data, struct domain_open_state);
io->out.domain_handle = s->domain_handle;
}
#include "lib/events/events.h"
#include "libnet/libnet.h"
#include "libcli/composite/composite.h"
-#include "libcli/composite/monitor.h"
#include "libnet/composite.h"
#include "librpc/gen_ndr/ndr_nbt.h"
methods = (const char**)ctx->name_res_methods;
}
- c->private = s;
- c->state = SMBCLI_REQUEST_SEND;
+ c->private_data = s;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
/* send resolve request */
s->resolve_ctx = resolve_name_send(&s->hostname, c->event_ctx, methods);
NTSTATUS status;
struct lookup_state *s;
- s = talloc_get_type(c->private, struct lookup_state);
+ s = talloc_get_type(c->private_data, struct lookup_state);
status = resolve_name_recv(s->resolve_ctx, mem_ctx, s->address);
return status;
*/
#include "includes.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
-#include "libcli/composite/monitor.h"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userinfo.h"
struct samr_QueryUserInfo queryuserinfo;
struct samr_Close samrclose;
union samr_UserInfo *info;
+ /* information about the progress */
+ void (*monitor_fn)(struct monitor_msg *);
};
c->status = dcerpc_ndr_request_recv(s->req);
NT_STATUS_NOT_OK_RETURN(c->status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void userinfo_handler(struct rpc_request *req)
{
struct composite_context *c = req->async.private;
- struct userinfo_state *s = talloc_get_type(c->private, struct userinfo_state);
+ struct userinfo_state *s = talloc_get_type(c->private_data, struct userinfo_state);
struct monitor_msg msg;
struct msg_rpc_open_user *msg_open;
struct msg_rpc_query_user *msg_query;
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->monitor_fn) {
- c->monitor_fn(&msg);
+ if (s->monitor_fn) {
+ s->monitor_fn(&msg);
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
s->level = io->in.level;
s->pipe = p;
+ s->monitor_fn = monitor;
sid = dom_sid_parse_talloc(s, io->in.sid);
if (sid == NULL) goto failure;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = s;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data= s;
c->event_ctx = dcerpc_event_context(p);
- c->monitor_fn = monitor;
/* preparing parameters to send rpc request */
s->openuser.in.domain_handle = &io->in.domain_handle;
status = composite_wait(c);
if (NT_STATUS_IS_OK(status) && io) {
- s = talloc_get_type(c->private, struct userinfo_state);
+ s = talloc_get_type(c->private_data, struct userinfo_state);
talloc_steal(mem_ctx, s->info);
io->out.info = *s->info;
}
*/
#include "includes.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
-#include "libcli/composite/monitor.h"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userman.h"
struct samr_CreateUser createuser;
struct policy_handle user_handle;
uint32_t user_rid;
+ /* information about the progress */
+ void (*monitor_fn)(struct monitor_msg *);
};
c->status = dcerpc_ndr_request_recv(s->req);
NT_STATUS_NOT_OK_RETURN(c->status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void useradd_handler(struct rpc_request *req)
{
struct composite_context *c = req->async.private;
- struct useradd_state *s = talloc_get_type(c->private, struct useradd_state);
+ struct useradd_state *s = talloc_get_type(c->private_data, struct useradd_state);
struct monitor_msg msg;
struct msg_rpc_create_user *rpc_create;
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->monitor_fn) {
- c->monitor_fn(&msg);
+ if (s->monitor_fn) {
+ s->monitor_fn(&msg);
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
s->domain_handle = io->in.domain_handle;
s->pipe = p;
+ s->monitor_fn = monitor;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = s;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data= s;
c->event_ctx = dcerpc_event_context(p);
- c->monitor_fn = monitor;
/* preparing parameters to send rpc request */
s->createuser.in.domain_handle = &io->in.domain_handle;
if (NT_STATUS_IS_OK(status) && io) {
/* get and return result of the call */
- s = talloc_get_type(c->private, struct useradd_state);
+ s = talloc_get_type(c->private_data, struct useradd_state);
io->out.user_handle = s->user_handle;
}
struct samr_LookupNames lookupname;
struct samr_OpenUser openuser;
struct samr_DeleteUser deleteuser;
+ /* information about the progress */
+ void (*monitor_fn)(struct monitor_msg *);
};
c->status = dcerpc_ndr_request_recv(s->req);
NT_STATUS_NOT_OK_RETURN(c->status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void userdel_handler(struct rpc_request *req)
{
struct composite_context *c = req->async.private;
- struct userdel_state *s = talloc_get_type(c->private, struct userdel_state);
+ struct userdel_state *s = talloc_get_type(c->private_data, struct userdel_state);
struct monitor_msg msg;
struct msg_rpc_lookup_name *msg_lookup;
struct msg_rpc_open_user *msg_open;
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->monitor_fn) {
- c->monitor_fn(&msg);
+ if (s->monitor_fn) {
+ s->monitor_fn(&msg);
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
s = talloc_zero(c, struct userdel_state);
if (s == NULL) goto failure;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = s;
- c->event_ctx = dcerpc_event_context(p);
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data= s;
+ c->event_ctx = dcerpc_event_context(p);
s->pipe = p;
s->domain_handle = io->in.domain_handle;
/**
- * Waits for and receives results of asynchronous userdel call
+1 * Waits for and receives results of asynchronous userdel call
*
* @param c composite context returned by asynchronous userdel call
* @param mem_ctx memory context of the call
status = composite_wait(c);
if (NT_STATUS_IS_OK(status) && io) {
- s = talloc_get_type(c->private, struct userdel_state);
+ s = talloc_get_type(c->private_data, struct userdel_state);
io->out.user_handle = s->user_handle;
}
c->status = dcerpc_ndr_request_recv(s->req);
NT_STATUS_NOT_OK_RETURN(c->status);
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
static void usermod_handler(struct rpc_request *req)
{
struct composite_context *c = req->async.private;
- struct usermod_state *s = talloc_get_type(c->private, struct usermod_state);
- struct monitor_msg msg;
+ struct usermod_state *s = talloc_get_type(c->private_data, struct usermod_state);
switch (s->stage) {
case USERMOD_LOOKUP:
}
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
- }
-
- if (c->monitor_fn) {
- c->monitor_fn(&msg);
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
s = talloc_zero(c, struct usermod_state);
if (s == NULL) goto failure;
- c->state = SMBCLI_REQUEST_SEND;
- c->private = s;
- c->event_ctx = dcerpc_event_context(p);
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
+ c->private_data = s;
+ c->event_ctx = dcerpc_event_context(p);
s->pipe = p;
s->domain_handle = io->in.domain_handle;
#include "dlinklist.h"
#include "nbt_server/nbt_server.h"
#include "smbd/service_task.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
#include "librpc/gen_ndr/ndr_samr.h"
handle name refresh timer events
*/
static void name_refresh_handler(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private)
+ struct timeval t, void *private_data)
{
- struct nbtd_iface_name *iname = talloc_get_type(private, struct nbtd_iface_name);
+ struct nbtd_iface_name *iname = talloc_get_type(private_data, struct nbtd_iface_name);
struct nbtd_interface *iface = iname->iface;
struct nbt_name_register io;
struct nbt_name_request *req;
/*
a name registration has completed
*/
-static void nbtd_register_handler(struct composite_context *req)
+static void nbtd_register_handler(struct composite_context *creq)
{
- struct nbtd_iface_name *iname = talloc_get_type(req->async.private,
+ struct nbtd_iface_name *iname = talloc_get_type(creq->async.private_data,
struct nbtd_iface_name);
NTSTATUS status;
TALLOC_CTX *tmp_ctx = talloc_new(iname);
- status = nbt_name_register_bcast_recv(req);
+ status = nbt_name_register_bcast_recv(creq);
if (NT_STATUS_IS_OK(status)) {
/* good - nobody complained about our registration */
iname->nb_flags |= NBT_NM_ACTIVE;
struct nbtd_iface_name *iname;
const char *scope = lp_netbios_scope();
struct nbt_name_register_bcast io;
- struct composite_context *req;
+ struct composite_context *creq;
struct nbtd_server *nbtsrv = iface->nbtsrv;
iname = talloc(iface, struct nbtd_iface_name);
io.in.ttl = iname->ttl;
nbtsrv->stats.total_sent++;
- req = nbt_name_register_bcast_send(iface->nbtsock, &io);
- if (req == NULL) return;
+ creq = nbt_name_register_bcast_send(iface->nbtsock, &io);
+ if (creq == NULL) return;
- req->async.fn = nbtd_register_handler;
- req->async.private = iname;
+ creq->async.fn = nbtd_register_handler;
+ creq->async.private_data = iname;
}
#include "includes.h"
#include "nbt_server/nbt_server.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
#include "lib/events/events.h"
#include "smbd/service_task.h"
static void nbtd_wins_refresh(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private);
+ struct timeval t, void *private_data);
/*
retry a WINS name registration
*/
static void nbtd_wins_register_retry(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private)
+ struct timeval t, void *private_data)
{
- struct nbtd_iface_name *iname = talloc_get_type(private, struct nbtd_iface_name);
+ struct nbtd_iface_name *iname = talloc_get_type(private_data, struct nbtd_iface_name);
nbtd_winsclient_register(iname);
}
{
NTSTATUS status;
struct nbt_name_refresh_wins io;
- struct nbtd_iface_name *iname = talloc_get_type(c->async.private,
+ struct nbtd_iface_name *iname = talloc_get_type(c->async.private_data,
struct nbtd_iface_name);
TALLOC_CTX *tmp_ctx = talloc_new(iname);
nbt_name_string(tmp_ctx, &iname->name), nt_errstr(status)));
talloc_free(tmp_ctx);
return;
- }
+ }
if (io.out.rcode != 0) {
DEBUG(1,("WINS server %s rejected name refresh of %s - %s\n",
refresh a WINS name registration
*/
static void nbtd_wins_refresh(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private)
+ struct timeval t, void *private_data)
{
- struct nbtd_iface_name *iname = talloc_get_type(private, struct nbtd_iface_name);
+ struct nbtd_iface_name *iname = talloc_get_type(private_data, struct nbtd_iface_name);
struct nbtd_interface *iface = iname->iface;
struct nbt_name_refresh_wins io;
struct composite_context *c;
talloc_steal(c, io.in.addresses);
c->async.fn = nbtd_wins_refresh_handler;
- c->async.private = iname;
+ c->async.private_data = iname;
talloc_free(tmp_ctx);
}
{
NTSTATUS status;
struct nbt_name_register_wins io;
- struct nbtd_iface_name *iname = talloc_get_type(c->async.private,
+ struct nbtd_iface_name *iname = talloc_get_type(c->async.private_data,
struct nbtd_iface_name);
TALLOC_CTX *tmp_ctx = talloc_new(iname);
talloc_steal(c, io.in.addresses);
c->async.fn = nbtd_wins_register_handler;
- c->async.private = iname;
+ c->async.private_data = iname;
}
#include "lib/events/events.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "smb_server/smb_server.h"
#include "smbd/service_stream.h"
#include "libcli/raw/libcliraw.h"
#include "system/time.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
static BOOL try_failed_login(struct smbcli_state *cli)
{
#include "includes.h"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
-#include "libcli/composite/monitor.h"
static BOOL test_domainopen(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
struct lsa_String *domname,
#include "lib/cmdline/popt_common.h"
#include "libnet/libnet.h"
#include "libnet/composite.h"
-#include "libcli/composite/monitor.h"
#include "librpc/gen_ndr/ndr_nbt.h"
#include "lib/cmdline/popt_common.h"
#include "libnet/libnet.h"
#include "libnet/composite.h"
-#include "libcli/composite/monitor.h"
BOOL test_lsa_connect(struct libnet_context *ctx)
#include "lib/cmdline/popt_common.h"
#include "libnet/libnet.h"
#include "libnet/composite.h"
-#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetusertest"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userinfo.h"
-#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetuserinfotest"
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userman.h"
-#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetusermantest"
struct dcerpc_pipe *p;
struct policy_handle h;
struct lsa_String domain_name;
- char *name = TEST_USERNAME;
+ const char *name = TEST_USERNAME;
TALLOC_CTX *mem_ctx;
BOOL ret = True;
int i;
#include "lib/events/events.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "lib/cmdline/popt_common.h"
#include "librpc/gen_ndr/ndr_security.h"
static void loadfile_complete(struct composite_context *c)
{
- int *count = talloc_get_type(c->async.private, int);
+ int *count = talloc_get_type(c->async.private_data, int);
(*count)++;
}
for (i=0;i<num_ops;i++) {
c[i] = smb_composite_loadfile_send(cli->tree, &io2);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
printf("waiting for completion\n");
for (i=0; i<torture_numops; i++) {
c[i] = smb_composite_fetchfile_send(&io2, event_ctx);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
printf("waiting for completion\n");
c[i] = smb_composite_appendacl_send(cli->tree, io[i]);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
event_ctx = talloc_reference(mem_ctx, cli->tree->session->transport->socket->event.ctx);
for (i=0; i<torture_numops; i++) {
c[i] = smb_composite_fsinfo_send(cli->tree,&io1);
c[i]->async.fn = loadfile_complete;
- c[i]->async.private = count;
+ c[i]->async.private_data = count;
}
printf("waiting for completion\n");
#include "libcli/raw/libcliraw.h"
#include "librpc/gen_ndr/ndr_security.h"
#include "libcli/composite/composite.h"
+#include "libcli/smb_composite/smb_composite.h"
#include "lib/cmdline/popt_common.h"
#include "lib/events/events.h"
*/
#include "includes.h"
-#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
#include "winbind/wb_async_helpers.h"
struct irpc_request *ireq;
};
-static void finddcs_getdc(struct irpc_request *req)
+static void finddcs_getdc(struct irpc_request *ireq)
{
- struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context *c = talloc_get_type(ireq->async.private,
struct composite_context);
- struct finddcs_state *state =
- talloc_get_type(c->private, struct finddcs_state);
+ struct finddcs_state *state = talloc_get_type(c->private_data,
+ struct finddcs_state);
- c->status = irpc_call_recv(req);
+ c->status = irpc_call_recv(ireq);
if (!NT_STATUS_IS_OK(c->status)) {
goto done;
}
state->r->out.dcname);
c->status = NT_STATUS_OK;
- c->state = SMBCLI_REQUEST_DONE;
+ c->state = COMPOSITE_STATE_DONE;
done:
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
*/
static void finddcs_resolve(struct composite_context *res_ctx)
{
- struct composite_context *c = talloc_get_type(res_ctx->async.private,
+ struct composite_context *c = talloc_get_type(res_ctx->async.private_data,
struct composite_context);
- struct finddcs_state *state =
- talloc_get_type(c->private, struct finddcs_state);
+ struct finddcs_state *state = talloc_get_type(c->private_data,
+ struct finddcs_state);
uint32_t *nbt_servers;
state->io->out.num_dcs = 1;
done:
if (!NT_STATUS_IS_OK(c->status)) {
- c->state = SMBCLI_REQUEST_ERROR;
+ c->state = COMPOSITE_STATE_ERROR;
}
- if (c->state >= SMBCLI_REQUEST_DONE &&
+ if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
c = talloc_zero(NULL, struct composite_context);
if (c == NULL) goto failed;
- c->state = SMBCLI_REQUEST_SEND;
+ c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = event_ctx;
state = talloc(c, struct finddcs_state);
lp_name_resolve_order());
if (state->creq == NULL) goto failed;
- state->creq->async.private = c;
+ state->creq->async.private_data = c;
state->creq->async.fn = finddcs_resolve;
- c->private = state;
+ c->private_data = state;
return c;
failed:
status = composite_wait(c);
if (NT_STATUS_IS_OK(status)) {
- struct finddcs_state *state =
- talloc_get_type(c->private, struct finddcs_state);
+ struct finddcs_state *state = talloc_get_type(c->private_data,
+ struct finddcs_state);
talloc_steal(mem_ctx, state->io->out.dcs);
}
static void wbsrv_samba3_check_machacc_reply(struct composite_context *action)
{
struct wbsrv_samba3_call *s3call =
- talloc_get_type(action->async.private,
+ talloc_get_type(action->async.private_data,
struct wbsrv_samba3_call);
struct check_machacc_state *state =
talloc_get_type(s3call->private_data,
/* setup the callbacks */
resolve_req->async.fn = wbsrv_samba3_check_machacc_reply;
- resolve_req->async.private = s3call;
+ resolve_req->async.private_data = s3call;
/* tell the caller we reply later */
s3call->call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
git.samba.org / gd / samba-autobuild / .git / commitdiff