sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-08-04 08:22:08 +03:00
Code Activity

r10504: - seperate implementation specific stuff, from the generic composite

Browse Source 
stuff.
- don't use SMBCLI_REQUEST_* state's in the genreic composite stuff
- move monitor_fn to libnet.

NOTE: I have maybe found some bugs, in code that is dirrectly in DONE or ERROR
      state in the _send() function. I haven't fixed this bugs in this
      commit! We may need some composite_trigger_*() functions or so.
      And maybe some other generic helper functions...

metze
(This used to be commit 4527815a0a)
This commit is contained in:
Stefan Metzmacher
2005-09-26 11:47:55 +00:00
committed by Gerald (Jerry) Carter
parent 0d46be147a
commit ab4d635b92
39 changed files with 501 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
source4/libcli/cliconnect.c
View File

@ -23,6 +23,7 @@
#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()

4
source4/libcli/composite/composite.c
View File

@ -34,7 +34,7 @@ NTSTATUS composite_wait(struct composite_context *c)
{
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;
}
@ -51,7 +51,6 @@ static void composite_trigger(struct event_context *ev, struct timed_event *te,
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);
}
@ -65,6 +64,7 @@ static void composite_trigger(struct event_context *ev, struct timed_event *te,
*/
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);
}

147
source4/libcli/composite/composite.h
View File

@ -1,7 +1,7 @@
/*
Unix SMB/CIFS implementation.
SMB composite request interfaces
composite request interfaces
Copyright (C) Andrew Tridgell 2005
@ -23,19 +23,28 @@
/*
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;
@ -46,132 +55,6 @@ struct composite_context {
/* 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;
};

42
source4/libcli/composite/monitor.h
View File

@ -1,42 +0,0 @@
/*
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;
};

24
source4/libcli/config.mk
View File

@ -10,21 +10,21 @@ ADD_OBJ_FILES = libcli/util/asn1.o \
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 = \
@ -34,7 +34,7 @@ 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]
@ -69,7 +69,7 @@ REQUIRED_SUBSYSTEMS = LIBCLI_NBT
[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]

21
source4/libcli/nbt/namerefresh.c
View File

@ -22,7 +22,6 @@
#include "includes.h"
#include "libcli/nbt/libnbt.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
/*
@ -154,7 +153,7 @@ static void name_refresh_wins_handler(struct nbt_name_request *req)
{
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;
@ -164,7 +163,7 @@ static void name_refresh_wins_handler(struct nbt_name_request *req)
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;
}
@ -172,14 +171,14 @@ static void name_refresh_wins_handler(struct nbt_name_request *req)
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 &&
@ -188,20 +187,20 @@ static void name_refresh_wins_handler(struct nbt_name_request *req)
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);
}
@ -251,8 +250,8 @@ struct composite_context *nbt_name_refresh_wins_send(struct nbt_name_socket *nbt
state->req->async.fn = name_refresh_wins_handler;
state->req->async.private = c;
c->private = state;
c->state = SMBCLI_REQUEST_SEND;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = nbtsock->event_ctx;
return c;
@ -272,7 +271,7 @@ NTSTATUS nbt_name_refresh_wins_recv(struct composite_context *c, TALLOC_CTX *mem
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;
}

37
source4/libcli/nbt/nameregister.c
View File

@ -22,7 +22,6 @@
#include "includes.h"
#include "libcli/nbt/libnbt.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
/*
@ -156,14 +155,14 @@ struct register_bcast_state {
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;
}
@ -173,17 +172,17 @@ static void name_register_bcast_handler(struct nbt_name_request *req)
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,
@ -193,7 +192,7 @@ static void name_register_bcast_handler(struct nbt_name_request *req)
}
done:
if (c->state >= SMBCLI_REQUEST_DONE &&
if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
@ -236,8 +235,8 @@ struct composite_context *nbt_name_register_bcast_send(struct nbt_name_socket *n
state->req->async.fn = name_register_bcast_handler;
state->req->async.private = c;
c->private = state;
c->state = SMBCLI_REQUEST_SEND;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = nbtsock->event_ctx;
return c;
@ -291,7 +290,7 @@ static void name_register_wins_handler(struct nbt_name_request *req)
{
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;
@ -301,7 +300,7 @@ static void name_register_wins_handler(struct nbt_name_request *req)
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;
}
@ -309,14 +308,14 @@ static void name_register_wins_handler(struct nbt_name_request *req)
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 &&
@ -325,20 +324,20 @@ static void name_register_wins_handler(struct nbt_name_request *req)
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);
}
@ -390,8 +389,8 @@ struct composite_context *nbt_name_register_wins_send(struct nbt_name_socket *nb
state->req->async.fn = name_register_wins_handler;
state->req->async.private = c;
c->private = state;
c->state = SMBCLI_REQUEST_SEND;
c->private_data = state;
c->state = COMPOSITE_STATE_IN_PROGRESS;
c->event_ctx = nbtsock->event_ctx;
return c;
@ -411,7 +410,7 @@ NTSTATUS nbt_name_register_wins_recv(struct composite_context *c, TALLOC_CTX *me
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;
}

16
source4/libcli/raw/clisocket.c
View File

@ -78,17 +78,17 @@ static NTSTATUS smbcli_sock_connect_one(struct smbcli_socket *sock,
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);
}
@ -107,7 +107,7 @@ static void smbcli_sock_connect_handler(struct event_context *ev, struct fd_even
}
}
c->state = SMBCLI_REQUEST_ERROR;
c->state = COMPOSITE_STATE_ERROR;
if (c->async.fn) {
c->async.fn(c);
}
@ -195,8 +195,8 @@ struct composite_context *smbcli_sock_connect_send(struct smbcli_socket *sock,
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 */
@ -212,7 +212,7 @@ struct composite_context *smbcli_sock_connect_send(struct smbcli_socket *sock,
}
}
c->state = SMBCLI_REQUEST_ERROR;
c->state = COMPOSITE_STATE_ERROR;
return c;
failed:

1
source4/libcli/raw/clitree.c
View File

@ -24,6 +24,7 @@
#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); \

18
source4/libcli/resolve/host.c
View File

@ -66,7 +66,7 @@ static int host_destructor(void *ptr)
*/
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;
@ -84,10 +84,10 @@ static void run_child(struct composite_context *c, int fd)
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;
@ -113,7 +113,7 @@ static void pipe_handler(struct event_context *ev, struct fd_event *fde,
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);
}
@ -121,7 +121,7 @@ static void pipe_handler(struct event_context *ev, struct fd_event *fde,
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);
}
@ -148,8 +148,8 @@ struct composite_context *resolve_name_host_send(struct nbt_name *name,
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 */
@ -206,7 +206,7 @@ NTSTATUS resolve_name_host_recv(struct composite_context *c,
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);
}

16
source4/libcli/resolve/nbtlist.c
View File

@ -45,7 +45,7 @@ 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 nbtlist_state *state = talloc_get_type(c->private_data, struct nbtlist_state);
int i;
for (i=0;i<state->num_queries;i++) {
@ -54,20 +54,20 @@ static void nbtlist_handler(struct nbt_name_request *req)
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++) {
@ -150,8 +150,8 @@ struct composite_context *resolve_name_nbtlist_send(struct nbt_name *name,
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;
@ -172,7 +172,7 @@ NTSTATUS resolve_name_nbtlist_recv(struct composite_context *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);
}

46
source4/libcli/resolve/resolve.c
View File

@ -28,7 +28,7 @@
struct resolve_state {
struct nbt_name name;
const char **methods;
struct composite_context *req;
struct composite_context *creq;
const char *reply_addr;
};
@ -65,26 +65,26 @@ static const struct resolve_method *find_method(const char *name)
/*
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);
@ -94,23 +94,23 @@ static void resolve_handler(struct composite_context *req)
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;
}
/*
@ -136,8 +136,8 @@ struct composite_context *resolve_name_send(struct nbt_name *name, struct event_
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;
@ -154,8 +154,8 @@ struct composite_context *resolve_name_send(struct nbt_name *name, struct event_
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;
@ -175,7 +175,7 @@ NTSTATUS resolve_name_recv(struct composite_context *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);
}

25
source4/libcli/composite/appendacl.c → source4/libcli/smb_composite/appendacl.c
View File

@ -1,6 +1,7 @@
#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 */
@ -24,7 +25,7 @@ struct appendacl_state {
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;
@ -55,7 +56,7 @@ static NTSTATUS appendacl_open(struct composite_context *c,
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;
@ -101,7 +102,7 @@ static NTSTATUS appendacl_get(struct composite_context *c,
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;
@ -134,7 +135,7 @@ static NTSTATUS appendacl_set(struct composite_context *c,
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;
@ -170,13 +171,13 @@ static NTSTATUS appendacl_getagain(struct composite_context *c,
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;
}
@ -187,7 +188,7 @@ static NTSTATUS appendacl_close(struct composite_context *c,
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 */
@ -215,10 +216,10 @@ static void appendacl_handler(struct smbcli_request *req)
/* 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);
}
@ -243,8 +244,8 @@ struct composite_context *smb_composite_appendacl_send(struct smbcli_tree *tree,
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 */
@ -289,7 +290,7 @@ NTSTATUS smb_composite_appendacl_recv(struct composite_context *c, TALLOC_CTX *m
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);
}

41
source4/libcli/composite/connect.c → source4/libcli/smb_composite/connect.c
View File

@ -24,6 +24,7 @@
#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,
@ -55,7 +56,7 @@ static void composite_handler(struct composite_context *);
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);
@ -74,7 +75,7 @@ static NTSTATUS connect_send_negprot(struct composite_context *c,
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);
@ -91,7 +92,7 @@ static NTSTATUS connect_tcon(struct composite_context *c,
}
/* all done! */
c->state = SMBCLI_REQUEST_DONE;
c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
@ -103,7 +104,7 @@ static NTSTATUS connect_tcon(struct composite_context *c,
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);
@ -153,7 +154,7 @@ static NTSTATUS connect_session_setup(struct composite_context *c,
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);
@ -174,12 +175,12 @@ static NTSTATUS connect_negprot(struct composite_context *c,
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;
@ -192,7 +193,7 @@ static NTSTATUS connect_negprot(struct composite_context *c,
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);
@ -208,7 +209,7 @@ static NTSTATUS connect_session_request(struct composite_context *c,
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;
@ -250,7 +251,7 @@ static NTSTATUS connect_socket(struct composite_context *c,
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;
@ -261,7 +262,7 @@ static NTSTATUS connect_resolve(struct composite_context *c,
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;
@ -273,7 +274,7 @@ static NTSTATUS connect_resolve(struct composite_context *c,
*/
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:
@ -297,10 +298,10 @@ static void state_handler(struct composite_context *c)
}
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);
}
@ -320,9 +321,9 @@ static void request_handler(struct smbcli_request *req)
/*
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);
}
@ -348,16 +349,16 @@ struct composite_context *smb_composite_connect_send(struct smb_composite_connec
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;
@ -376,7 +377,7 @@ NTSTATUS smb_composite_connect_recv(struct composite_context *c, TALLOC_CTX *mem
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);
}

47
source4/libcli/composite/fetchfile.c → source4/libcli/smb_composite/fetchfile.c
View File

@ -24,6 +24,7 @@
#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};
@ -31,7 +32,7 @@ enum fetchfile_stage {FETCHFILE_CONNECT,
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;
};
@ -43,9 +44,9 @@ static NTSTATUS fetchfile_connect(struct composite_context *c,
{
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);
@ -53,15 +54,15 @@ static NTSTATUS fetchfile_connect(struct composite_context *c,
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;
}
@ -71,15 +72,15 @@ static NTSTATUS fetchfile_read(struct composite_context *c,
{
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);
@ -91,7 +92,7 @@ static void fetchfile_state_handler(struct composite_context *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 */
@ -106,16 +107,16 @@ static void fetchfile_state_handler(struct composite_context *c)
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 *c = talloc_get_type(creq->async.private_data,
struct composite_context);
fetchfile_state_handler(c);
}
@ -145,16 +146,16 @@ struct composite_context *smb_composite_fetchfile_send(struct smb_composite_fetc
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:
@ -170,7 +171,7 @@ NTSTATUS smb_composite_fetchfile_recv(struct composite_context *c,
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);
}

35
source4/libcli/composite/fsinfo.c → source4/libcli/smb_composite/fsinfo.c
View File

@ -5,6 +5,7 @@
#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 */
@ -30,7 +31,7 @@ static NTSTATUS fsinfo_connect(struct composite_context *c,
{
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);
@ -59,14 +60,14 @@ static NTSTATUS fsinfo_query(struct composite_context *c,
{
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);
@ -78,28 +79,28 @@ static NTSTATUS fsinfo_query(struct composite_context *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);
}
}
@ -114,9 +115,9 @@ static void fsinfo_raw_handler(struct smbcli_request *req)
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);
}
@ -150,16 +151,16 @@ struct composite_context *smb_composite_fsinfo_send(struct smbcli_tree *tree,
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;
@ -178,7 +179,7 @@ NTSTATUS smb_composite_fsinfo_recv(struct composite_context *c, TALLOC_CTX *mem_
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);
}

23
source4/libcli/composite/loadfile.c → source4/libcli/smb_composite/loadfile.c
View File

@ -24,6 +24,7 @@
#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 */
@ -46,7 +47,7 @@ struct loadfile_state {
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 */
@ -75,7 +76,7 @@ static NTSTATUS setup_close(struct composite_context *c,
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;
@ -129,7 +130,7 @@ static NTSTATUS loadfile_open(struct composite_context *c,
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;
@ -163,13 +164,13 @@ static NTSTATUS loadfile_read(struct composite_context *c,
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;
}
@ -181,7 +182,7 @@ static NTSTATUS loadfile_close(struct composite_context *c,
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 */
@ -200,10 +201,10 @@ static void loadfile_handler(struct smbcli_request *req)
}
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);
}
@ -227,8 +228,8 @@ struct composite_context *smb_composite_loadfile_send(struct smbcli_tree *tree,
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 */
@ -271,7 +272,7 @@ NTSTATUS smb_composite_loadfile_recv(struct composite_context *c, TALLOC_CTX *me
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);
}

21
source4/libcli/composite/savefile.c → source4/libcli/smb_composite/savefile.c
View File

@ -24,6 +24,7 @@
#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 */
@ -47,7 +48,7 @@ struct savefile_state {
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 */
@ -76,7 +77,7 @@ static NTSTATUS setup_close(struct composite_context *c,
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;
@ -122,7 +123,7 @@ static NTSTATUS savefile_open(struct composite_context *c,
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;
@ -160,7 +161,7 @@ static NTSTATUS savefile_write(struct composite_context *c,
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);
@ -170,7 +171,7 @@ static NTSTATUS savefile_close(struct composite_context *c,
return NT_STATUS_DISK_FULL;
}
c->state = SMBCLI_REQUEST_DONE;
c->state = COMPOSITE_STATE_DONE;
return NT_STATUS_OK;
}
@ -182,7 +183,7 @@ static NTSTATUS savefile_close(struct composite_context *c,
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 */
@ -201,10 +202,10 @@ static void savefile_handler(struct smbcli_request *req)
}
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);
}
@ -224,7 +225,7 @@ struct composite_context *smb_composite_savefile_send(struct smbcli_tree *tree,
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);
@ -255,7 +256,7 @@ struct composite_context *smb_composite_savefile_send(struct smbcli_tree *tree,
/* setup the callback handler */
state->req->async.fn = savefile_handler;
state->req->async.private = c;
c->private = state;
c->private_data = state;
return c;

23
source4/libcli/composite/sesssetup.c → source4/libcli/smb_composite/sesssetup.c
View File

@ -24,6 +24,7 @@
#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"
@ -74,7 +75,7 @@ static void set_user_session_key(struct smbcli_session *session,
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);
@ -144,9 +145,9 @@ static void request_handler(struct smbcli_request *req)
}
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);
@ -162,7 +163,7 @@ static NTSTATUS session_setup_nt1(struct composite_context *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);
@ -252,7 +253,7 @@ static NTSTATUS session_setup_old(struct composite_context *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 char *password = cli_credentials_get_password(io->in.credentials);
state->setup.old.level = RAW_SESSSETUP_OLD;
@ -293,7 +294,7 @@ static NTSTATUS session_setup_spnego(struct composite_context *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);
NTSTATUS status, session_key_err;
DATA_BLOB session_key = data_blob(NULL, 0);
DATA_BLOB null_data_blob = data_blob(NULL, 0);
@ -397,20 +398,20 @@ struct composite_context *smb_composite_sesssetup_send(struct smbcli_session *se
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;
}
@ -431,7 +432,7 @@ struct composite_context *smb_composite_sesssetup_send(struct smbcli_session *se
return c;
}
c->state = SMBCLI_REQUEST_ERROR;
c->state = COMPOSITE_STATE_ERROR;
c->status = status;
return c;
}

152
source4/libcli/smb_composite/smb_composite.h Normal file
View File

@ -0,0 +1,152 @@
/*
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;
};

19
source4/libnet/composite.h
View File

@ -24,6 +24,25 @@
#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 {

20
source4/libnet/domain.c
View File

@ -23,9 +23,7 @@
*/
#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"
@ -119,7 +117,7 @@ static NTSTATUS domain_open_open(struct composite_context *c,
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;
}
@ -134,8 +132,7 @@ static NTSTATUS domain_open_open(struct composite_context *c,
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) {
@ -151,11 +148,7 @@ static void domain_open_handler(struct rpc_request *req)
}
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;
}
}
@ -179,10 +172,9 @@ struct composite_context *libnet_rpc_domain_open_send(struct dcerpc_pipe *p,
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;
@ -227,7 +219,7 @@ NTSTATUS libnet_rpc_domain_open_recv(struct composite_context *c, TALLOC_CTX *me
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;
}

7
source4/libnet/libnet_lookup.c
View File

@ -27,7 +27,6 @@
#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"
@ -78,8 +77,8 @@ struct composite_context *libnet_Lookup_send(struct libnet_context *ctx,
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);
@ -107,7 +106,7 @@ NTSTATUS libnet_Lookup_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
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;

24
source4/libnet/userinfo.c
View File

@ -23,9 +23,7 @@
*/
#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"
@ -44,6 +42,8 @@ struct userinfo_state {
struct samr_QueryUserInfo queryuserinfo;
struct samr_Close samrclose;
union samr_UserInfo *info;
/* information about the progress */
void (*monitor_fn)(struct monitor_msg *);
};
@ -113,7 +113,7 @@ static NTSTATUS userinfo_closeuser(struct composite_context *c,
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;
}
@ -128,7 +128,7 @@ static NTSTATUS userinfo_closeuser(struct composite_context *c,
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;
@ -169,14 +169,14 @@ static void userinfo_handler(struct rpc_request *req)
}
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);
}
@ -207,13 +207,13 @@ struct composite_context *libnet_rpc_userinfo_send(struct dcerpc_pipe *p,
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;
@ -256,7 +256,7 @@ NTSTATUS libnet_rpc_userinfo_recv(struct composite_context *c, TALLOC_CTX *mem_c
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;
}

63
source4/libnet/userman.c
View File

@ -23,9 +23,7 @@
*/
#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"
@ -47,6 +45,8 @@ struct useradd_state {
struct samr_CreateUser createuser;
struct policy_handle user_handle;
uint32_t user_rid;
/* information about the progress */
void (*monitor_fn)(struct monitor_msg *);
};
@ -59,7 +59,7 @@ static NTSTATUS useradd_create(struct composite_context *c,
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;
}
@ -73,7 +73,7 @@ static NTSTATUS useradd_create(struct composite_context *c,
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;
@ -90,14 +90,14 @@ static void useradd_handler(struct rpc_request *req)
}
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);
}
@ -126,11 +126,11 @@ struct composite_context *libnet_rpc_useradd_send(struct dcerpc_pipe *p,
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;
@ -174,7 +174,7 @@ NTSTATUS libnet_rpc_useradd_recv(struct composite_context *c, TALLOC_CTX *mem_ct
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;
}
@ -218,6 +218,8 @@ struct userdel_state {
struct samr_LookupNames lookupname;
struct samr_OpenUser openuser;
struct samr_DeleteUser deleteuser;
/* information about the progress */
void (*monitor_fn)(struct monitor_msg *);
};
@ -287,7 +289,7 @@ static NTSTATUS userdel_delete(struct composite_context *c,
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;
}
@ -302,7 +304,7 @@ static NTSTATUS userdel_delete(struct composite_context *c,
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;
@ -340,14 +342,14 @@ static void userdel_handler(struct rpc_request *req)
}
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);
}
@ -373,8 +375,8 @@ struct composite_context *libnet_rpc_userdel_send(struct dcerpc_pipe *p,
s = talloc_zero(c, struct userdel_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);
s->pipe = p;
@ -403,7 +405,7 @@ failure:
/**
* 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
@ -420,7 +422,7 @@ NTSTATUS libnet_rpc_userdel_recv(struct composite_context *c, TALLOC_CTX *mem_ct
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;
}
@ -672,7 +674,7 @@ static NTSTATUS usermod_modify(struct composite_context *c,
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;
}
@ -688,8 +690,7 @@ static NTSTATUS usermod_modify(struct composite_context *c,
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:
@ -710,14 +711,10 @@ static void usermod_handler(struct rpc_request *req)
}
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 (c->state >= SMBCLI_REQUEST_DONE &&
if (c->state >= COMPOSITE_STATE_DONE &&
c->async.fn) {
c->async.fn(c);
}
@ -743,8 +740,8 @@ struct composite_context *libnet_rpc_usermod_send(struct dcerpc_pipe *p,
s = talloc_zero(c, struct usermod_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);
s->pipe = p;

21
source4/nbt_server/register.c
View File

@ -25,7 +25,6 @@
#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"
@ -77,9 +76,9 @@ static void refresh_completion_handler(struct nbt_name_request *req)
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;
@ -130,14 +129,14 @@ static void nbtd_start_refresh_timer(struct nbtd_iface_name *iname)
/*
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;
@ -170,7 +169,7 @@ static void nbtd_register_name_iface(struct nbtd_interface *iface,
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);
@ -213,11 +212,11 @@ static void nbtd_register_name_iface(struct nbtd_interface *iface,
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;
}

19
source4/nbt_server/wins/winsclient.c
View File

@ -22,7 +22,6 @@
#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"
@ -38,15 +37,15 @@ static struct nbt_name_socket *wins_socket(struct nbtd_interface *iface)
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);
}
@ -58,7 +57,7 @@ static void nbtd_wins_refresh_handler(struct composite_context *c)
{
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);
@ -113,9 +112,9 @@ static void nbtd_wins_refresh_handler(struct composite_context *c)
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;
@ -136,7 +135,7 @@ static void nbtd_wins_refresh(struct event_context *ev, struct timed_event *te,
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);
}
@ -149,7 +148,7 @@ static void nbtd_wins_register_handler(struct composite_context *c)
{
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);
@ -227,5 +226,5 @@ void nbtd_winsclient_register(struct nbtd_iface_name *iname)
talloc_steal(c, io.in.addresses);
c->async.fn = nbtd_wins_register_handler;
c->async.private = iname;
c->async.private_data = iname;
}

1
source4/ntvfs/cifs/vfs_cifs.c
View File

@ -29,6 +29,7 @@
#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"

1
source4/torture/basic/secleak.c
View File

@ -24,6 +24,7 @@
#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)
{

1
source4/torture/libnet/domain.c
View File

@ -22,7 +22,6 @@
#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,

1
source4/torture/libnet/libnet_lookup.c
View File

@ -23,7 +23,6 @@
#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"

1
source4/torture/libnet/libnet_rpc.c
View File

@ -23,7 +23,6 @@
#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)

1
source4/torture/libnet/libnet_user.c
View File

@ -24,7 +24,6 @@
#include "lib/cmdline/popt_common.h"
#include "libnet/libnet.h"
#include "libnet/composite.h"
#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetusertest"

1
source4/torture/libnet/userinfo.c
View File

@ -23,7 +23,6 @@
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userinfo.h"
#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetuserinfotest"

3
source4/torture/libnet/userman.c
View File

@ -23,7 +23,6 @@
#include "librpc/gen_ndr/ndr_samr.h"
#include "libnet/composite.h"
#include "libnet/userman.h"
#include "libcli/composite/monitor.h"
#define TEST_USERNAME "libnetusermantest"
@ -412,7 +411,7 @@ BOOL torture_usermod(void)
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;

11
source4/torture/raw/composite.c
View File

@ -24,6 +24,7 @@
#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"
@ -31,7 +32,7 @@
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)++;
}
@ -76,7 +77,7 @@ static BOOL test_loadfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
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");
@ -163,7 +164,7 @@ static BOOL test_fetchfile(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
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");
@ -281,7 +282,7 @@ static BOOL test_appendacl(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
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);
@ -346,7 +347,7 @@ static BOOL test_fsinfo(struct smbcli_state *cli, TALLOC_CTX *mem_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");

1
source4/torture/raw/context.c
View File

@ -22,6 +22,7 @@
#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"

37
source4/winbind/wb_async_helpers.c
View File

@ -22,7 +22,6 @@
*/
#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/composite/composite.h"
#include "winbind/wb_async_helpers.h"
@ -40,14 +39,14 @@ struct finddcs_state {
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;
}
@ -56,14 +55,14 @@ static void finddcs_getdc(struct irpc_request *req)
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);
}
@ -74,10 +73,10 @@ static void finddcs_getdc(struct irpc_request *req)
*/
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;
@ -141,10 +140,10 @@ static void finddcs_resolve(struct composite_context *res_ctx)
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);
}
@ -159,7 +158,7 @@ struct composite_context *wb_finddcs_send(struct wb_finddcs *io,
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);
@ -172,9 +171,9 @@ struct composite_context *wb_finddcs_send(struct wb_finddcs *io,
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:
@ -189,8 +188,8 @@ NTSTATUS wb_finddcs_recv(struct composite_context *c, TALLOC_CTX *mem_ctx)
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);
}

4
source4/winbind/wb_samba3_cmd.c
View File

@ -60,7 +60,7 @@ struct check_machacc_state {
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,
@ -106,7 +106,7 @@ NTSTATUS wbsrv_samba3_check_machacc(struct wbsrv_samba3_call *s3call)
/* 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;