trying to get HEAD building again. If you want the code
[tprouty/samba.git] / source / passdb / privileges.c
1 /*
2  * Unix SMB/CIFS implementation. 
3  *
4  * default privileges backend for passdb
5  *
6  * Copyright (C) Andrew Tridgell 2003
7  * 
8  * This program is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option)
11  * any later version.
12  * 
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
16  * more details.
17  * 
18  * You should have received a copy of the GNU General Public License along with
19  * this program; if not, write to the Free Software Foundation, Inc., 675
20  * Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include "includes.h"
24
25 /*
26   this is a local implementation of a privileges backend, with
27   privileges stored in a tdb. Most passdb implementations will
28   probably use this backend, although some (such as pdb_ldap) will
29   store the privileges in another manner.
30
31   The basic principle is that the backend should store a list of SIDs
32   associated with each right, where a right is a string name such as
33   'SeTakeOwnershipPrivilege'. The SIDs can be of any type, and do not
34   need to belong to the local domain.
35
36   The way this is used is that certain places in the code which
37   require access control will ask the privileges backend 'does this
38   user have the following privilege'. The 'user' will be a NT_TOKEN,
39   which is essentially just a list of SIDs. If any of those SIDs are
40   listed in the list of SIDs for that privilege then the answer will
41   be 'yes'. That will usually mean that the user gets unconditional
42   access to that functionality, regradless of any ACLs. In this way
43   privileges act in a similar fashion to unix setuid bits.
44 */
45
46 /*
47   The terms 'right' and 'privilege' are used interchangably in this
48   file. This follows MSDN convention where the LSA calls are calls on
49   'rights', which really means privileges. My apologies for the
50   confusion.
51 */
52
53
54 /* 15 seconds seems like an ample time for timeouts on the privileges db */
55 #define LOCK_TIMEOUT 15
56
57
58 /* the tdb handle for the privileges database */
59 static TDB_CONTEXT *tdb;
60
61
62 /* initialise the privilege database */
63 BOOL privilege_init(void)
64 {
65         tdb = tdb_open_log(lock_path("privilege.tdb"), 0, TDB_DEFAULT, 
66                            O_RDWR|O_CREAT, 0600);
67         if (!tdb) {
68                 DEBUG(0,("Failed to open privilege database\n"));
69                 return False;
70         }
71
72         return True;
73 }
74
75 /* 
76    lock the record for a particular privilege (write lock)
77 */
78 static NTSTATUS privilege_lock_right(const char *right) 
79 {
80         if (tdb_lock_bystring(tdb, right, LOCK_TIMEOUT) != 0) {
81                 return NT_STATUS_INTERNAL_ERROR;
82         }
83         return NT_STATUS_OK;
84 }
85
86 /* 
87    unlock the record for a particular privilege (write lock)
88 */
89 static void privilege_unlock_right(const char *right) 
90 {
91         tdb_unlock_bystring(tdb, right);
92 }
93
94
95 /* 
96    return a list of SIDs that have a particular right
97 */
98 NTSTATUS privilege_enum_account_with_right(const char *right, 
99                                            uint32 *count, 
100                                            DOM_SID **sids)
101 {
102         TDB_DATA data;
103         char *p;
104         int i;
105
106         if (!tdb) {
107                 return NT_STATUS_INTERNAL_ERROR;
108         }
109
110         data = tdb_fetch_bystring(tdb, right);
111         if (!data.dptr) {
112                 *count = 0;
113                 *sids = NULL;
114                 return NT_STATUS_OK;
115         }
116
117         /* count them */
118         for (i=0, p=data.dptr; p<data.dptr+data.dsize; i++) {
119                 p += strlen(p) + 1;
120         }
121         *count = i;
122
123         /* allocate and parse */
124         *sids = malloc(sizeof(DOM_SID) * *count);
125         if (! *sids) {
126                 return NT_STATUS_NO_MEMORY;
127         }
128         for (i=0, p=data.dptr; p<data.dptr+data.dsize; i++) {
129                 if (!string_to_sid(&(*sids)[i], p)) {
130                         free(data.dptr);
131                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
132                 }
133                 p += strlen(p) + 1;
134         }
135         
136         free(data.dptr);
137
138         return NT_STATUS_OK;
139 }
140
141 /* 
142    set what accounts have a given right - this is an internal interface
143 */
144 static NTSTATUS privilege_set_accounts_with_right(const char *right, 
145                                                   uint32 count, 
146                                                   DOM_SID *sids)
147 {
148         TDB_DATA data;
149         char *p;
150         int i;
151
152         if (!tdb) {
153                 return NT_STATUS_INTERNAL_ERROR;
154         }
155
156         /* allocate the maximum size that we might use */
157         data.dptr = malloc(count * ((MAXSUBAUTHS*11) + 30));
158         if (!data.dptr) {
159                 return NT_STATUS_NO_MEMORY;
160         }
161
162         p = data.dptr;
163
164         for (i=0;i<count;i++) {
165                 sid_to_string(p, &sids[i]);
166                 p += strlen(p) + 1;
167         }
168
169         data.dsize = PTR_DIFF(p, data.dptr);
170
171         if (tdb_store_bystring(tdb, right, data, TDB_REPLACE) != 0) {
172                 free(data.dptr);
173                 return NT_STATUS_INTERNAL_ERROR;
174         }
175
176         free(data.dptr);
177         return NT_STATUS_OK;
178 }
179
180
181 /* 
182    add a SID to the list of SIDs for a right
183 */
184 NTSTATUS privilege_add_account_right(const char *right, 
185                                      DOM_SID *sid)
186 {
187         NTSTATUS status;
188         DOM_SID *current_sids;
189         uint32 current_count;
190         int i;
191
192         status = privilege_lock_right(right);
193         if (!NT_STATUS_IS_OK(status)) {
194                 return status;
195         }
196
197         status = privilege_enum_account_with_right(right, &current_count, &current_sids);
198         if (!NT_STATUS_IS_OK(status)) {
199                 privilege_unlock_right(right);
200                 return status;
201         }       
202
203         /* maybe that SID is already listed? this is not an error */
204         for (i=0;i<current_count;i++) {
205                 if (sid_equal(&current_sids[i], sid)) {
206                         privilege_unlock_right(right);
207                         free(current_sids);
208                         return NT_STATUS_OK;
209                 }
210         }
211
212         /* add it in */
213         current_sids = Realloc(current_sids, sizeof(current_sids[0]) * (current_count+1));
214         if (!current_sids) {
215                 privilege_unlock_right(right);
216                 return NT_STATUS_NO_MEMORY;
217         }
218
219         sid_copy(&current_sids[current_count], sid);
220         current_count++;
221         
222         status = privilege_set_accounts_with_right(right, current_count, current_sids);
223
224         free(current_sids);
225         privilege_unlock_right(right);
226
227         return status;
228 }
229
230
231 /* 
232    remove a SID from the list of SIDs for a right
233 */
234 NTSTATUS privilege_remove_account_right(const char *right, 
235                                         DOM_SID *sid)
236 {
237         NTSTATUS status;
238         DOM_SID *current_sids;
239         uint32 current_count;
240         int i;
241
242         status = privilege_lock_right(right);
243         if (!NT_STATUS_IS_OK(status)) {
244                 return status;
245         }
246
247         status = privilege_enum_account_with_right(right, &current_count, &current_sids);
248         if (!NT_STATUS_IS_OK(status)) {
249                 privilege_unlock_right(right);
250                 return status;
251         }       
252
253         for (i=0;i<current_count;i++) {
254                 if (sid_equal(&current_sids[i], sid)) {
255                         /* found it - so remove it */
256                         if (current_count-i > 1) {
257                                 memmove(&current_sids[i], &current_sids[i+1],
258                                         sizeof(current_sids[0]) * ((current_count-i)-1));
259                         }
260                         current_count--;
261                         status = privilege_set_accounts_with_right(right, 
262                                                                    current_count, 
263                                                                    current_sids);
264                         free(current_sids);
265                         privilege_unlock_right(right);
266                         return status;
267                 }
268         }
269
270         /* removing a right that you don't have is not an error */
271         
272         safe_free(current_sids);
273         privilege_unlock_right(right);
274         return NT_STATUS_OK;
275 }
276
277
278 /*
279   an internal function for checking if a SID has a right
280 */
281 static BOOL privilege_sid_has_right(DOM_SID *sid, const char *right)
282 {
283         NTSTATUS status;
284         uint32 count;
285         DOM_SID *sids;
286         int i;
287
288         status = privilege_enum_account_with_right(right, &count, &sids);
289         if (!NT_STATUS_IS_OK(status)) {
290                 return False;
291         }
292         for (i=0;i<count;i++) {
293                 if (sid_equal(sid, &sids[i])) {
294                         free(sids);
295                         return True;
296                 }
297         }       
298
299         safe_free(sids);
300         return False;
301 }
302
303 /* 
304    list the rights for an account. This involves traversing the database
305 */
306 NTSTATUS privilege_enum_account_rights(DOM_SID *sid,
307                                        uint32 *count,
308                                        char ***rights)
309 {
310         TDB_DATA key, nextkey;
311         char *right;
312
313         if (!tdb) {
314                 return NT_STATUS_INTERNAL_ERROR;
315         }
316
317         *rights = NULL;
318         *count = 0;
319
320         for (key = tdb_firstkey(tdb); key.dptr; key = nextkey) {
321                 nextkey = tdb_nextkey(tdb, key);
322
323                 right = key.dptr;
324                 
325                 if (privilege_sid_has_right(sid, right)) {
326                         (*rights) = (char **)Realloc(*rights,sizeof(char *) * ((*count)+1));
327                         if (! *rights) {
328                                 safe_free(nextkey.dptr);
329                                 free(key.dptr);
330                                 return NT_STATUS_NO_MEMORY;
331                         }
332
333                         (*rights)[*count] = strdup(right);
334                         (*count)++;
335                 }
336
337                 free(key.dptr);
338         }
339
340         return NT_STATUS_OK;
341 }