2 Unix SMB/CIFS implementation.
4 Copyright (C) Rafal Szczesniak 2007
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 3 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, see <http://www.gnu.org/licenses/>.
21 a composite function for getting group information via samr pipe
26 #include "libcli/composite/composite.h"
27 #include "libnet/composite.h"
28 #include "librpc/gen_ndr/security.h"
29 #include "libcli/security/security.h"
30 #include "libnet/userman.h"
31 #include "libnet/groupinfo.h"
32 #include "librpc/gen_ndr/ndr_samr_c.h"
33 #include "libnet/libnet_proto.h"
36 struct groupinfo_state
{
37 struct dcerpc_pipe
*pipe
;
38 struct policy_handle domain_handle
;
39 struct policy_handle group_handle
;
41 struct samr_LookupNames lookup
;
42 struct samr_OpenGroup opengroup
;
43 struct samr_QueryGroupInfo querygroupinfo
;
44 struct samr_Close samrclose
;
45 union samr_GroupInfo
*info
;
47 /* information about the progress */
48 void (*monitor_fn
)(struct monitor_msg
*);
52 static void continue_groupinfo_lookup(struct rpc_request
*req
);
53 static void continue_groupinfo_opengroup(struct rpc_request
*req
);
54 static void continue_groupinfo_getgroup(struct rpc_request
*req
);
55 static void continue_groupinfo_closegroup(struct rpc_request
*req
);
59 * Stage 1 (optional): Look for a group name in SAM server.
61 static void continue_groupinfo_lookup(struct rpc_request
*req
)
63 struct composite_context
*c
;
64 struct groupinfo_state
*s
;
65 struct rpc_request
*opengroup_req
;
66 struct monitor_msg msg
;
67 struct msg_rpc_lookup_name
*msg_lookup
;
69 c
= talloc_get_type(req
->async
.private_data
, struct composite_context
);
70 s
= talloc_get_type(c
->private_data
, struct groupinfo_state
);
72 /* receive samr_Lookup reply */
73 c
->status
= dcerpc_ndr_request_recv(req
);
74 if (!composite_is_ok(c
)) return;
76 /* there could be a problem with name resolving itself */
77 if (!NT_STATUS_IS_OK(s
->lookup
.out
.result
)) {
78 composite_error(c
, s
->lookup
.out
.result
);
82 /* issue a monitor message */
84 msg
.type
= mon_SamrLookupName
;
85 msg_lookup
= talloc(s
, struct msg_rpc_lookup_name
);
86 msg_lookup
->rid
= s
->lookup
.out
.rids
->ids
;
87 msg_lookup
->count
= s
->lookup
.out
.rids
->count
;
88 msg
.data
= (void*)msg_lookup
;
89 msg
.data_size
= sizeof(*msg_lookup
);
95 /* have we actually got name resolved
96 - we're looking for only one at the moment */
97 if (s
->lookup
.out
.rids
->count
== 0) {
98 composite_error(c
, NT_STATUS_NO_SUCH_USER
);
101 /* TODO: find proper status code for more than one rid found */
103 /* prepare parameters for LookupNames */
104 s
->opengroup
.in
.domain_handle
= &s
->domain_handle
;
105 s
->opengroup
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
106 s
->opengroup
.in
.rid
= s
->lookup
.out
.rids
->ids
[0];
107 s
->opengroup
.out
.group_handle
= &s
->group_handle
;
110 opengroup_req
= dcerpc_samr_OpenGroup_send(s
->pipe
, c
, &s
->opengroup
);
111 if (composite_nomem(opengroup_req
, c
)) return;
113 composite_continue_rpc(c
, opengroup_req
, continue_groupinfo_opengroup
, c
);
118 * Stage 2: Open group policy handle.
120 static void continue_groupinfo_opengroup(struct rpc_request
*req
)
122 struct composite_context
*c
;
123 struct groupinfo_state
*s
;
124 struct rpc_request
*querygroup_req
;
125 struct monitor_msg msg
;
126 struct msg_rpc_open_group
*msg_open
;
128 c
= talloc_get_type(req
->async
.private_data
, struct composite_context
);
129 s
= talloc_get_type(c
->private_data
, struct groupinfo_state
);
131 /* receive samr_OpenGroup reply */
132 c
->status
= dcerpc_ndr_request_recv(req
);
133 if (!composite_is_ok(c
)) return;
135 if (!NT_STATUS_IS_OK(s
->querygroupinfo
.out
.result
)) {
136 composite_error(c
, s
->querygroupinfo
.out
.result
);
140 /* issue a monitor message */
142 msg
.type
= mon_SamrOpenGroup
;
143 msg_open
= talloc(s
, struct msg_rpc_open_group
);
144 msg_open
->rid
= s
->opengroup
.in
.rid
;
145 msg_open
->access_mask
= s
->opengroup
.in
.access_mask
;
146 msg
.data
= (void*)msg_open
;
147 msg
.data_size
= sizeof(*msg_open
);
152 /* prepare parameters for QueryGroupInfo call */
153 s
->querygroupinfo
.in
.group_handle
= &s
->group_handle
;
154 s
->querygroupinfo
.in
.level
= s
->level
;
155 s
->querygroupinfo
.out
.info
= talloc(s
, union samr_GroupInfo
*);
156 if (composite_nomem(s
->querygroupinfo
.out
.info
, c
)) return;
158 /* queue rpc call, set event handling and new state */
159 querygroup_req
= dcerpc_samr_QueryGroupInfo_send(s
->pipe
, c
, &s
->querygroupinfo
);
160 if (composite_nomem(querygroup_req
, c
)) return;
162 composite_continue_rpc(c
, querygroup_req
, continue_groupinfo_getgroup
, c
);
167 * Stage 3: Get requested group information.
169 static void continue_groupinfo_getgroup(struct rpc_request
*req
)
171 struct composite_context
*c
;
172 struct groupinfo_state
*s
;
173 struct rpc_request
*close_req
;
174 struct monitor_msg msg
;
175 struct msg_rpc_query_group
*msg_query
;
177 c
= talloc_get_type(req
->async
.private_data
, struct composite_context
);
178 s
= talloc_get_type(c
->private_data
, struct groupinfo_state
);
180 /* receive samr_QueryGroupInfo reply */
181 c
->status
= dcerpc_ndr_request_recv(req
);
182 if (!composite_is_ok(c
)) return;
184 /* check if querygroup itself went ok */
185 if (!NT_STATUS_IS_OK(s
->querygroupinfo
.out
.result
)) {
186 composite_error(c
, s
->querygroupinfo
.out
.result
);
190 s
->info
= talloc_steal(s
, *s
->querygroupinfo
.out
.info
);
192 /* issue a monitor message */
194 msg
.type
= mon_SamrQueryGroup
;
195 msg_query
= talloc(s
, struct msg_rpc_query_group
);
196 msg_query
->level
= s
->querygroupinfo
.in
.level
;
197 msg
.data
= (void*)msg_query
;
198 msg
.data_size
= sizeof(*msg_query
);
203 /* prepare arguments for Close call */
204 s
->samrclose
.in
.handle
= &s
->group_handle
;
205 s
->samrclose
.out
.handle
= &s
->group_handle
;
207 /* queue rpc call, set event handling and new state */
208 close_req
= dcerpc_samr_Close_send(s
->pipe
, c
, &s
->samrclose
);
209 if (composite_nomem(close_req
, c
)) return;
211 composite_continue_rpc(c
, close_req
, continue_groupinfo_closegroup
, c
);
216 * Stage 4: Close policy handle associated with opened group.
218 static void continue_groupinfo_closegroup(struct rpc_request
*req
)
220 struct composite_context
*c
;
221 struct groupinfo_state
*s
;
222 struct monitor_msg msg
;
223 struct msg_rpc_close_group
*msg_close
;
225 c
= talloc_get_type(req
->async
.private_data
, struct composite_context
);
226 s
= talloc_get_type(c
->private_data
, struct groupinfo_state
);
228 /* receive samr_Close reply */
229 c
->status
= dcerpc_ndr_request_recv(req
);
230 if (!composite_is_ok(c
)) return;
232 if (!NT_STATUS_IS_OK(s
->samrclose
.out
.result
)) {
233 composite_error(c
, s
->samrclose
.out
.result
);
237 /* issue a monitor message */
239 msg
.type
= mon_SamrClose
;
240 msg_close
= talloc(s
, struct msg_rpc_close_group
);
241 msg_close
->rid
= s
->opengroup
.in
.rid
;
242 msg
.data
= (void*)msg_close
;
243 msg
.data_size
= sizeof(*msg_close
);
253 * Sends asynchronous groupinfo request
255 * @param p dce/rpc call pipe
256 * @param io arguments and results of the call
258 struct composite_context
*libnet_rpc_groupinfo_send(struct dcerpc_pipe
*p
,
259 struct libnet_rpc_groupinfo
*io
,
260 void (*monitor
)(struct monitor_msg
*))
262 struct composite_context
*c
;
263 struct groupinfo_state
*s
;
265 struct rpc_request
*opengroup_req
, *lookup_req
;
267 if (!p
|| !io
) return NULL
;
269 c
= composite_create(p
, dcerpc_event_context(p
));
270 if (c
== NULL
) return c
;
272 s
= talloc_zero(c
, struct groupinfo_state
);
273 if (composite_nomem(s
, c
)) return c
;
277 s
->level
= io
->in
.level
;
279 s
->domain_handle
= io
->in
.domain_handle
;
280 s
->monitor_fn
= monitor
;
283 sid
= dom_sid_parse_talloc(s
, io
->in
.sid
);
284 if (composite_nomem(sid
, c
)) return c
;
286 s
->opengroup
.in
.domain_handle
= &s
->domain_handle
;
287 s
->opengroup
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
288 s
->opengroup
.in
.rid
= sid
->sub_auths
[sid
->num_auths
- 1];
289 s
->opengroup
.out
.group_handle
= &s
->group_handle
;
292 opengroup_req
= dcerpc_samr_OpenGroup_send(p
, c
, &s
->opengroup
);
293 if (composite_nomem(opengroup_req
, c
)) return c
;
295 composite_continue_rpc(c
, opengroup_req
, continue_groupinfo_opengroup
, c
);
298 /* preparing parameters to send rpc request */
299 s
->lookup
.in
.domain_handle
= &s
->domain_handle
;
300 s
->lookup
.in
.num_names
= 1;
301 s
->lookup
.in
.names
= talloc_array(s
, struct lsa_String
, 1);
302 if (composite_nomem(s
->lookup
.in
.names
, c
)) return c
;
304 s
->lookup
.in
.names
[0].string
= talloc_strdup(s
, io
->in
.groupname
);
305 if (composite_nomem(s
->lookup
.in
.names
[0].string
, c
)) return c
;
306 s
->lookup
.out
.rids
= talloc_zero(s
, struct samr_Ids
);
307 s
->lookup
.out
.types
= talloc_zero(s
, struct samr_Ids
);
308 if (composite_nomem(s
->lookup
.out
.rids
, c
)) return c
;
309 if (composite_nomem(s
->lookup
.out
.types
, c
)) return c
;
312 lookup_req
= dcerpc_samr_LookupNames_send(p
, c
, &s
->lookup
);
313 if (composite_nomem(lookup_req
, c
)) return c
;
315 composite_continue_rpc(c
, lookup_req
, continue_groupinfo_lookup
, c
);
323 * Waits for and receives result of asynchronous groupinfo call
325 * @param c composite context returned by asynchronous groupinfo call
326 * @param mem_ctx memory context of the call
327 * @param io pointer to results (and arguments) of the call
328 * @return nt status code of execution
331 NTSTATUS
libnet_rpc_groupinfo_recv(struct composite_context
*c
, TALLOC_CTX
*mem_ctx
,
332 struct libnet_rpc_groupinfo
*io
)
335 struct groupinfo_state
*s
;
337 /* wait for results of sending request */
338 status
= composite_wait(c
);
340 if (NT_STATUS_IS_OK(status
) && io
) {
341 s
= talloc_get_type(c
->private_data
, struct groupinfo_state
);
342 talloc_steal(mem_ctx
, s
->info
);
343 io
->out
.info
= *s
->info
;
346 /* memory context associated to composite context is no longer needed */
353 * Synchronous version of groupinfo call
355 * @param pipe dce/rpc call pipe
356 * @param mem_ctx memory context for the call
357 * @param io arguments and results of the call
358 * @return nt status code of execution
361 NTSTATUS
libnet_rpc_groupinfo(struct dcerpc_pipe
*p
,
363 struct libnet_rpc_groupinfo
*io
)
365 struct composite_context
*c
= libnet_rpc_groupinfo_send(p
, io
, NULL
);
366 return libnet_rpc_groupinfo_recv(c
, mem_ctx
, io
);