2 Unix SMB/CIFS implementation.
4 Copyright (C) Rafal Szczesniak 2005
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 a composite functions for user management operations (add/del/chg)
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/composite/composite.h"
28 #include "librpc/gen_ndr/ndr_samr.h"
29 #include "libnet/composite.h"
32 * Composite user add function
35 static void useradd_handler(struct rpc_request*);
37 enum useradd_stage { USERADD_CREATE };
39 struct useradd_state {
40 enum useradd_stage stage;
41 struct dcerpc_pipe *pipe;
42 struct rpc_request *req;
43 struct policy_handle domain_handle;
44 struct samr_CreateUser createuser;
45 struct policy_handle user_handle;
51 * Stage 1 (and the only one for now): Create user account.
53 static NTSTATUS useradd_create(struct composite_context *c,
54 struct useradd_state *s)
56 c->status = dcerpc_ndr_request_recv(s->req);
57 NT_STATUS_NOT_OK_RETURN(c->status);
59 c->state = SMBCLI_REQUEST_DONE;
65 * Event handler for asynchronous request. Handles transition through
66 * intermediate stages of the call.
68 * @param req rpc call context
70 static void useradd_handler(struct rpc_request *req)
72 struct composite_context *c = req->async.private;
73 struct useradd_state *s = talloc_get_type(c->private, struct useradd_state);
77 c->status = useradd_create(c, s);
81 if (!NT_STATUS_IS_OK(c->status)) {
82 c->state = SMBCLI_REQUEST_ERROR;
85 if (c->state >= SMBCLI_REQUEST_DONE &&
93 * Sends asynchronous useradd request
95 * @param p dce/rpc call pipe
96 * @param io arguments and results of the call
98 struct composite_context *rpc_composite_useradd_send(struct dcerpc_pipe *p,
99 struct rpc_composite_useradd *io)
101 struct composite_context *c;
102 struct useradd_state *s;
105 c = talloc_zero(p, struct composite_context);
106 if (c == NULL) goto failure;
108 s = talloc_zero(c, struct useradd_state);
109 if (s == NULL) goto failure;
111 s->domain_handle = io->in.domain_handle;
114 c->state = SMBCLI_REQUEST_SEND;
116 c->event_ctx = dcerpc_event_context(p);
118 /* preparing parameters to send rpc request */
119 s->createuser.in.domain_handle = &io->in.domain_handle;
120 s->createuser.in.account_name = talloc_zero(c, struct samr_String);
121 s->createuser.in.account_name->string = talloc_strdup(c, io->in.username);
122 s->createuser.out.user_handle = &s->user_handle;
123 s->createuser.out.rid = &s->user_rid;
126 s->req = dcerpc_samr_CreateUser_send(p, c, &s->createuser);
128 /* callback handler */
129 s->req->async.callback = useradd_handler;
130 s->req->async.private = c;
131 s->stage = USERADD_CREATE;
142 * Waits for and receives result of asynchronous useradd call
144 * @param c composite context returned by asynchronous userinfo call
145 * @param mem_ctx memory context of the call
146 * @param io pointer to results (and arguments) of the call
147 * @return nt status code of execution
150 NTSTATUS rpc_composite_useradd_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
151 struct rpc_composite_useradd *io)
154 struct useradd_state *s;
156 status = composite_wait(c);
158 if (NT_STATUS_IS_OK(status) && io) {
159 /* get and return result of the call */
160 s = talloc_get_type(c->private, struct useradd_state);
161 io->out.user_handle = s->user_handle;
170 * Synchronous version of useradd call
172 * @param pipe dce/rpc call pipe
173 * @param mem_ctx memory context for the call
174 * @param io arguments and results of the call
175 * @return nt status code of execution
178 NTSTATUS rpc_composite_useradd(struct dcerpc_pipe *pipe,
180 struct rpc_composite_useradd *io)
182 struct composite_context *c = rpc_composite_useradd_send(pipe, io);
183 return rpc_composite_useradd_recv(c, mem_ctx, io);
188 * Composite user del function
191 static void userdel_handler(struct rpc_request*);
193 enum userdel_stage { USERDEL_LOOKUP, USERDEL_OPEN, USERDEL_DELETE };
195 struct userdel_state {
196 enum userdel_stage stage;
197 struct dcerpc_pipe *pipe;
198 struct rpc_request *req;
199 struct policy_handle domain_handle;
200 struct policy_handle user_handle;
201 struct samr_LookupNames lookupname;
202 struct samr_OpenUser openuser;
203 struct samr_DeleteUser deleteuser;
207 static NTSTATUS userdel_lookup(struct composite_context *c,
208 struct userdel_state *s)
210 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
212 c->status = dcerpc_ndr_request_recv(s->req);
213 NT_STATUS_NOT_OK_RETURN(c->status);
215 if (!s->lookupname.out.rids.count) {
216 /* TODO: no such user */
217 status = NT_STATUS_NO_SUCH_USER;
219 } else if (!s->lookupname.out.rids.count > 1) {
220 /* TODO: ambiguous username */
221 status = NT_STATUS_INVALID_ACCOUNT_NAME;
224 s->openuser.in.domain_handle = &s->domain_handle;
225 s->openuser.in.rid = s->lookupname.out.rids.ids[0];
226 s->openuser.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
227 s->openuser.out.user_handle = &s->user_handle;
229 s->req = dcerpc_samr_OpenUser_send(s->pipe, c, &s->openuser);
231 s->req->async.callback = userdel_handler;
232 s->req->async.private = c;
233 s->stage = USERDEL_OPEN;
242 static NTSTATUS userdel_open(struct composite_context *c,
243 struct userdel_state *s)
245 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
247 c->status = dcerpc_ndr_request_recv(s->req);
248 NT_STATUS_NOT_OK_RETURN(c->status);
250 s->deleteuser.in.user_handle = &s->user_handle;
251 s->deleteuser.out.user_handle = &s->user_handle;
253 s->req = dcerpc_samr_DeleteUser_send(s->pipe, c, &s->deleteuser);
255 s->req->async.callback = userdel_handler;
256 s->req->async.private = c;
257 s->stage = USERDEL_DELETE;
263 static NTSTATUS userdel_delete(struct composite_context *c,
264 struct userdel_state *s)
266 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
268 c->status = dcerpc_ndr_request_recv(s->req);
269 NT_STATUS_NOT_OK_RETURN(c->status);
271 c->state = SMBCLI_REQUEST_DONE;
277 static void userdel_handler(struct rpc_request *req)
279 struct composite_context *c = req->async.private;
280 struct userdel_state *s = talloc_get_type(c->private, struct userdel_state);
284 c->status = userdel_lookup(c, s);
287 c->status = userdel_open(c, s);
290 c->status = userdel_delete(c, s);
294 if (!NT_STATUS_IS_OK(c->status)) {
295 c->state = SMBCLI_REQUEST_ERROR;
298 if (c->state >= SMBCLI_REQUEST_DONE &&
305 struct composite_context *rpc_composite_userdel_send(struct dcerpc_pipe *p,
306 struct rpc_composite_userdel *io)
308 struct composite_context *c;
309 struct userdel_state *s;
311 c = talloc_zero(p, struct composite_context);
312 if (c == NULL) goto failure;
314 s = talloc_zero(c, struct userdel_state);
315 if (s == NULL) goto failure;
318 c->state = SMBCLI_REQUEST_SEND;
320 c->event_ctx = dcerpc_event_context(p);
322 s->lookupname.in.domain_handle = &io->in.domain_handle;
323 s->lookupname.in.num_names = 1;
324 s->lookupname.in.names = talloc_zero(s, struct samr_String);
325 s->lookupname.in.names->string = io->in.username;
327 s->req = dcerpc_samr_LookupNames_send(p, c, &s->lookupname);
329 s->req->async.callback = userdel_handler;
330 s->req->async.private = c;
331 s->stage = USERDEL_LOOKUP;
341 NTSTATUS rpc_composite_userdel_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
342 struct rpc_composite_userdel *io)
345 struct userdel_state *s;
347 status = composite_wait(c);
349 if (NT_STATUS_IS_OK(status) && io) {
350 s = talloc_get_type(c->private, struct userdel_state);
351 io->out.user_handle = s->user_handle;
359 NTSTATUS rpc_composite_userdel(struct dcerpc_pipe *pipe,
361 struct rpc_composite_userdel *io)
363 struct composite_context *c = rpc_composite_userdel_send(pipe, io);
364 return rpc_composite_userdel_recv(c, mem_ctx, io);