r4201: Remove duplicate const.
[samba.git] / source / libcli / util / clilsa.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    lsa calls for file sharing connections
5
6    Copyright (C) Andrew Tridgell 2004
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /*
24   when dealing with ACLs the file sharing client code needs to
25   sometimes make LSA RPC calls. This code provides an easy interface
26   for doing those calls.  
27 */
28
29 #include "includes.h"
30 #include "libcli/raw/libcliraw.h"
31 #include "librpc/gen_ndr/ndr_lsa.h"
32
33 struct smblsa_state {
34         struct dcerpc_pipe *pipe;
35         struct smbcli_tree *ipc_tree;
36         struct policy_handle handle;
37 };
38
39 /*
40   establish the lsa pipe connection
41 */
42 static NTSTATUS smblsa_connect(struct smbcli_state *cli)
43 {
44         struct smblsa_state *lsa;
45         NTSTATUS status;
46         struct lsa_OpenPolicy r;
47         uint16_t system_name = '\\';
48         union smb_tcon tcon;
49         struct lsa_ObjectAttribute attr;
50         struct lsa_QosInfo qos;
51
52         if (cli->lsa != NULL) {
53                 return NT_STATUS_OK;
54         }
55
56         lsa = talloc_p(cli, struct smblsa_state);
57         if (lsa == NULL) {
58                 return NT_STATUS_NO_MEMORY;
59         }
60
61         lsa->ipc_tree = smbcli_tree_init(cli->session);
62         if (lsa->ipc_tree == NULL) {
63                 return NT_STATUS_NO_MEMORY;
64         }
65
66         /* connect to IPC$ */
67         tcon.generic.level = RAW_TCON_TCONX;
68         tcon.tconx.in.flags = 0;
69         tcon.tconx.in.password = data_blob(NULL, 0);
70         tcon.tconx.in.path = "ipc$";
71         tcon.tconx.in.device = "IPC";   
72         status = smb_tree_connect(lsa->ipc_tree, lsa, &tcon);
73         if (!NT_STATUS_IS_OK(status)) {
74                 talloc_free(lsa);
75                 return status;
76         }
77         lsa->ipc_tree->tid = tcon.tconx.out.cnum;
78
79         /* open the LSA pipe */
80         status = dcerpc_pipe_open_smb(&lsa->pipe, lsa->ipc_tree, DCERPC_LSARPC_NAME);
81         if (!NT_STATUS_IS_OK(status)) {
82                 talloc_free(lsa);
83                 return status;
84         }
85
86         /* bind to the LSA pipe */
87         status = dcerpc_bind_auth_none(lsa->pipe, DCERPC_LSARPC_UUID, DCERPC_LSARPC_VERSION);
88         if (!NT_STATUS_IS_OK(status)) {
89                 talloc_free(lsa);
90                 return status;
91         }
92
93
94         /* open a lsa policy handle */
95         qos.len = 0;
96         qos.impersonation_level = 2;
97         qos.context_mode = 1;
98         qos.effective_only = 0;
99
100         attr.len = 0;
101         attr.root_dir = NULL;
102         attr.object_name = NULL;
103         attr.attributes = 0;
104         attr.sec_desc = NULL;
105         attr.sec_qos = &qos;
106
107         r.in.system_name = &system_name;
108         r.in.attr = &attr;
109         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
110         r.out.handle = &lsa->handle;
111
112         status = dcerpc_lsa_OpenPolicy(lsa->pipe, lsa, &r);
113         if (!NT_STATUS_IS_OK(status)) {
114                 talloc_free(lsa);
115                 return status;
116         }
117
118         cli->lsa = lsa;
119         
120         return NT_STATUS_OK;
121 }
122
123
124 /*
125   return the set of privileges for the given sid
126 */
127 NTSTATUS smblsa_sid_privileges(struct smbcli_state *cli, struct dom_sid *sid, 
128                                TALLOC_CTX *mem_ctx,
129                                struct lsa_RightSet *rights)
130 {
131         NTSTATUS status;
132         struct lsa_EnumAccountRights r;
133
134         status = smblsa_connect(cli);
135         if (!NT_STATUS_IS_OK(status)) {
136                 return status;
137         }
138
139         r.in.handle = &cli->lsa->handle;
140         r.in.sid = sid;
141         r.out.rights = rights;
142
143         return dcerpc_lsa_EnumAccountRights(cli->lsa->pipe, mem_ctx, &r);
144 }
145
146
147 /*
148   check if a named sid has a particular named privilege
149 */
150 NTSTATUS smblsa_sid_check_privilege(struct smbcli_state *cli, 
151                                     const char *sid_str,
152                                     const char *privilege)
153 {
154         struct lsa_RightSet rights;
155         NTSTATUS status;
156         TALLOC_CTX *mem_ctx = talloc(cli, 0);
157         struct dom_sid *sid;
158         unsigned i;
159
160         sid = dom_sid_parse_talloc(mem_ctx, sid_str);
161         if (sid == NULL) {
162                 talloc_free(mem_ctx);
163                 return NT_STATUS_INVALID_SID;
164         }
165
166         status = smblsa_sid_privileges(cli, sid, mem_ctx, &rights);
167         if (!NT_STATUS_IS_OK(status)) {
168                 talloc_free(mem_ctx);
169                 return status;
170         }
171
172         for (i=0;i<rights.count;i++) {
173                 if (strcmp(rights.names[i].string, privilege) == 0) {
174                         talloc_free(mem_ctx);
175                         return NT_STATUS_OK;
176                 }
177         }
178
179         talloc_free(mem_ctx);
180         return NT_STATUS_NOT_FOUND;
181 }
182
183
184 /*
185   lookup a SID, returning its name
186 */
187 NTSTATUS smblsa_lookup_sid(struct smbcli_state *cli, 
188                            const char *sid_str,
189                            TALLOC_CTX *mem_ctx,
190                            const char **name)
191 {
192         struct lsa_LookupSids r;
193         struct lsa_TransNameArray names;
194         struct lsa_SidArray sids;
195         uint32_t count = 1;
196         NTSTATUS status;
197         struct dom_sid *sid;
198         TALLOC_CTX *mem_ctx2 = talloc(mem_ctx, 0);
199
200         status = smblsa_connect(cli);
201         if (!NT_STATUS_IS_OK(status)) {
202                 return status;
203         }
204
205         sid = dom_sid_parse_talloc(mem_ctx2, sid_str);
206         if (sid == NULL) {
207                 return NT_STATUS_INVALID_SID;
208         }
209
210         names.count = 0;
211         names.names = NULL;
212
213         sids.num_sids = 1;
214         sids.sids = talloc_p(mem_ctx2, struct lsa_SidPtr);
215         sids.sids[0].sid = sid;
216
217         r.in.handle = &cli->lsa->handle;
218         r.in.sids = &sids;
219         r.in.names = &names;
220         r.in.level = 1;
221         r.in.count = &count;
222         r.out.count = &count;
223         r.out.names = &names;
224
225         status = dcerpc_lsa_LookupSids(cli->lsa->pipe, mem_ctx2, &r);
226         if (!NT_STATUS_IS_OK(status)) {
227                 talloc_free(mem_ctx2);
228                 return status;
229         }
230         if (names.count != 1) {
231                 talloc_free(mem_ctx2);
232                 return NT_STATUS_UNSUCCESSFUL;
233         }
234
235         (*name) = talloc_asprintf(mem_ctx, "%s\\%s", 
236                                   r.out.domains->domains[0].name.string,
237                                   names.names[0].name.string);
238
239         talloc_free(mem_ctx2);
240
241         return NT_STATUS_OK;    
242 }
243
244 /*
245   lookup a name, returning its sid
246 */
247 NTSTATUS smblsa_lookup_name(struct smbcli_state *cli, 
248                             const char *name,
249                             TALLOC_CTX *mem_ctx,
250                             const char **sid_str)
251 {
252         struct lsa_LookupNames r;
253         struct lsa_TransSidArray sids;
254         struct lsa_String names;
255         uint32_t count = 1;
256         NTSTATUS status;
257         struct dom_sid *sid;
258         TALLOC_CTX *mem_ctx2 = talloc(mem_ctx, 0);
259         uint32_t rid;
260
261         status = smblsa_connect(cli);
262         if (!NT_STATUS_IS_OK(status)) {
263                 return status;
264         }
265
266         sids.count = 0;
267         sids.sids = NULL;
268
269         names.string = name;
270
271         r.in.handle = &cli->lsa->handle;
272         r.in.num_names = 1;
273         r.in.names = &names;
274         r.in.sids = &sids;
275         r.in.level = 1;
276         r.in.count = &count;
277         r.out.count = &count;
278         r.out.sids = &sids;
279
280         status = dcerpc_lsa_LookupNames(cli->lsa->pipe, mem_ctx2, &r);
281         if (!NT_STATUS_IS_OK(status)) {
282                 talloc_free(mem_ctx2);
283                 return status;
284         }
285         if (sids.count != 1) {
286                 talloc_free(mem_ctx2);
287                 return NT_STATUS_UNSUCCESSFUL;
288         }
289
290         sid = r.out.domains->domains[0].sid;
291         rid = sids.sids[0].rid;
292         
293         (*sid_str) = talloc_asprintf(mem_ctx, "%s-%u", 
294                                      dom_sid_string(mem_ctx2, sid), rid);
295
296         talloc_free(mem_ctx2);
297
298         return NT_STATUS_OK;    
299 }