trying to get HEAD building again. If you want the code
[gd/samba-autobuild/.git] / source3 / sam / idmap.c
1 /* 
2    Unix SMB/CIFS implementation.
3    ID Mapping
4    Copyright (C) Tim Potter 2000
5    Copyright (C) Anthony Liguori <aliguor@us.ibm.com>   2003
6    Copyright (C) Simo Sorce 2003
7    Copyright (C) Jeremy Allison 2003.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.*/
22
23 #include "includes.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_IDMAP
27
28 struct idmap_function_entry {
29         const char *name;
30         struct idmap_methods *methods;
31         struct idmap_function_entry *prev,*next;
32 };
33
34 static struct idmap_function_entry *backends = NULL;
35
36 static struct idmap_methods *cache_map;
37 static struct idmap_methods *remote_map;
38
39 /**********************************************************************
40  Get idmap methods. Don't allow tdb to be a remote method.
41 **********************************************************************/
42
43 static struct idmap_methods *get_methods(const char *name, BOOL cache_method)
44 {
45         struct idmap_function_entry *entry = backends;
46
47         for(entry = backends; entry; entry = entry->next) {
48                 if (!cache_method && strequal(entry->name, "tdb"))
49                         continue; /* tdb is only cache method. */
50                 if (strequal(entry->name, name))
51                         return entry->methods;
52         }
53
54         return NULL;
55 }
56
57 /**********************************************************************
58  Allow a module to register itself as a method.
59 **********************************************************************/
60
61 NTSTATUS smb_register_idmap(int version, const char *name, struct idmap_methods *methods)
62 {
63         struct idmap_function_entry *entry;
64
65         if ((version != SMB_IDMAP_INTERFACE_VERSION)) {
66                 DEBUG(0, ("smb_register_idmap: Failed to register idmap module.\n"
67                           "The module was compiled against SMB_IDMAP_INTERFACE_VERSION %d,\n"
68                           "current SMB_IDMAP_INTERFACE_VERSION is %d.\n"
69                           "Please recompile against the current version of samba!\n",  
70                           version, SMB_IDMAP_INTERFACE_VERSION));
71                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
72         }
73
74         if (!name || !name[0] || !methods) {
75                 DEBUG(0,("smb_register_idmap: called with NULL pointer or empty name!\n"));
76                 return NT_STATUS_INVALID_PARAMETER;
77         }
78
79         if (get_methods(name, False)) {
80                 DEBUG(0,("smb_register_idmap: idmap module %s already registered!\n", name));
81                 return NT_STATUS_OBJECT_NAME_COLLISION;
82         }
83
84         entry = smb_xmalloc(sizeof(struct idmap_function_entry));
85         entry->name = smb_xstrdup(name);
86         entry->methods = methods;
87
88         DLIST_ADD(backends, entry);
89         DEBUG(5, ("smb_register_idmap: Successfully added idmap backend '%s'\n", name));
90         return NT_STATUS_OK;
91 }
92
93 /**********************************************************************
94  Initialise idmap cache and a remote backend (if configured).
95 **********************************************************************/
96
97 BOOL idmap_init(const char *remote_backend)
98 {
99         if (!backends)
100                 static_init_idmap;
101
102         if (!cache_map) {
103                 cache_map = get_methods("tdb", True);
104
105                 if (!cache_map) {
106                         DEBUG(0, ("idmap_init: could not find tdb cache backend!\n"));
107                         return False;
108                 }
109                 
110                 if (!NT_STATUS_IS_OK(cache_map->init( NULL ))) {
111                         DEBUG(0, ("idmap_init: could not initialise tdb cache backend!\n"));
112                         return False;
113                 }
114         }
115         
116         if (!remote_map && remote_backend && *remote_backend != 0) {
117                 char *rem_backend = smb_xstrdup(remote_backend);
118                 fstring params = "";
119                 char *pparams;
120                 
121                 /* get any mode parameters passed in */
122                 
123                 if ( (pparams = strchr( rem_backend, ':' )) != NULL ) {
124                         *pparams = '\0';
125                         pparams++;
126                         fstrcpy( params, pparams );
127                 }
128                 
129                 DEBUG(3, ("idmap_init: using '%s' as remote backend\n", rem_backend));
130                 
131                 if((remote_map = get_methods(rem_backend, False)) ||
132                     (NT_STATUS_IS_OK(smb_probe_module("idmap", rem_backend)) && 
133                     (remote_map = get_methods(rem_backend, False)))) {
134                         remote_map->init(params);
135                 } else {
136                         DEBUG(0, ("idmap_init: could not load remote backend '%s'\n", rem_backend));
137                         SAFE_FREE(rem_backend);
138                         return False;
139                 }
140                 SAFE_FREE(rem_backend);
141         }
142
143         return True;
144 }
145
146 /**************************************************************************
147  This is a rare operation, designed to allow an explicit mapping to be
148  set up for a sid to a POSIX id.
149 **************************************************************************/
150
151 NTSTATUS idmap_set_mapping(const DOM_SID *sid, unid_t id, int id_type)
152 {
153         struct idmap_methods *map = remote_map;
154         DOM_SID tmp_sid;
155
156         DEBUG(10, ("idmap_set_mapping: Set %s to %s %d\n",
157                    sid_string_static(sid),
158                    ((id_type & ID_TYPEMASK) == ID_USERID) ? "UID" : "GID",
159                    ((id_type & ID_TYPEMASK) == ID_USERID) ? id.uid : id.gid));
160
161         if ( (NT_STATUS_IS_OK(cache_map->
162                               get_sid_from_id(&tmp_sid, id,
163                                               id_type | ID_QUERY_ONLY))) &&
164              sid_equal(sid, &tmp_sid) ) {
165                 /* Nothing to do, we already have that mapping */
166                 DEBUG(10, ("idmap_set_mapping: Mapping already there\n"));
167                 return NT_STATUS_OK;
168         }
169
170         if (map == NULL) {
171                 /* Ok, we don't have a authoritative remote
172                         mapping. So update our local cache only. */
173                 map = cache_map;
174         }
175
176         return map->set_mapping(sid, id, id_type);
177 }
178
179 /**************************************************************************
180  Get ID from SID. This can create a mapping for a SID to a POSIX id.
181 **************************************************************************/
182
183 NTSTATUS idmap_get_id_from_sid(unid_t *id, int *id_type, const DOM_SID *sid)
184 {
185         NTSTATUS ret;
186         int loc_type;
187
188         loc_type = *id_type;
189
190         if (remote_map) {
191                 /* We have a central remote idmap so only look in
192                    cache, don't allocate */
193                 loc_type |= ID_QUERY_ONLY;
194         }
195
196         ret = cache_map->get_id_from_sid(id, &loc_type, sid);
197
198         if (NT_STATUS_IS_OK(ret)) {
199                 *id_type = loc_type & ID_TYPEMASK;
200                 return NT_STATUS_OK;
201         }
202
203         if (remote_map == NULL) {
204                 return ret;
205         }
206
207         /* Ok, the mapping was not in the cache, give the remote map a
208            second try. */
209
210         ret = remote_map->get_id_from_sid(id, id_type, sid);
211         
212         if (NT_STATUS_IS_OK(ret)) {
213                 /* The remote backend gave us a valid mapping, cache it. */
214                 ret = cache_map->set_mapping(sid, *id, *id_type);
215         }
216
217         return ret;
218 }
219
220 /**************************************************************************
221  Get SID from ID. This must have been created before.
222 **************************************************************************/
223
224 NTSTATUS idmap_get_sid_from_id(DOM_SID *sid, unid_t id, int id_type)
225 {
226         NTSTATUS ret;
227         int loc_type;
228
229         loc_type = id_type;
230         if (remote_map) {
231                 loc_type = id_type | ID_QUERY_ONLY;
232         }
233
234         ret = cache_map->get_sid_from_id(sid, id, loc_type);
235
236         if (NT_STATUS_IS_OK(ret))
237                 return ret;
238
239         if (remote_map == NULL)
240                 return ret;
241
242         /* We have a second chance, ask our authoritative backend */
243
244         ret = remote_map->get_sid_from_id(sid, id, id_type);
245
246         if (NT_STATUS_IS_OK(ret)) {
247                 /* The remote backend gave us a valid mapping, cache it. */
248                 ret = cache_map->set_mapping(sid, id, id_type);
249         }
250
251         return ret;
252 }
253
254 /**************************************************************************
255  Alloocate a new UNIX uid/gid
256 **************************************************************************/
257
258 NTSTATUS idmap_allocate_id(unid_t *id, int id_type)
259 {
260         /* we have to allocate from the authoritative backend */
261         
262         if ( remote_map )
263                 return remote_map->allocate_id( id, id_type );
264
265         return cache_map->allocate_id( id, id_type );
266 }
267
268 /**************************************************************************
269  Alloocate a new RID
270 **************************************************************************/
271
272 NTSTATUS idmap_allocate_rid(uint32 *rid, int type)
273 {
274         /* we have to allocate from the authoritative backend */
275         
276         if ( remote_map )
277                 return remote_map->allocate_rid( rid, type );
278
279         return cache_map->allocate_rid( rid, type );
280 }
281
282 /**************************************************************************
283  Shutdown maps.
284 **************************************************************************/
285
286 NTSTATUS idmap_close(void)
287 {
288         NTSTATUS ret;
289
290         ret = cache_map->close();
291         if (!NT_STATUS_IS_OK(ret)) {
292                 DEBUG(3, ("idmap_close: failed to close local tdb cache!\n"));
293         }
294         cache_map = NULL;
295
296         if (remote_map) {
297                 ret = remote_map->close();
298                 if (!NT_STATUS_IS_OK(ret)) {
299                         DEBUG(3, ("idmap_close: failed to close remote idmap repository!\n"));
300                 }
301                 remote_map = NULL;
302         }
303
304         return ret;
305 }
306
307 /**************************************************************************
308  Dump backend status.
309 **************************************************************************/
310
311 void idmap_status(void)
312 {
313         cache_map->status();
314         if (remote_map)
315                 remote_map->status();
316 }