*id_to_*id call reshape to return NTSTATUS errors
[ira/wip.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
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 #include "includes.h"
23
24 #undef DBGC_CLASS
25 #define DBGC_CLASS DBGC_IDMAP
26
27 static struct {
28
29         const char *name;
30         /* Function to create a member of the idmap_methods list */
31         NTSTATUS (*reg_meth)(struct idmap_methods **methods);
32         struct idmap_methods *methods;
33
34 } remote_idmap_functions[] = {
35         { NULL, NULL, NULL }
36 };
37
38 static struct idmap_methods *local_map;
39 static struct idmap_methods *remote_map;
40
41 static void lazy_initialize_idmap(void)
42 {
43         static BOOL initialized = False;
44         if (initialized) return;
45         idmap_init();
46         initialized = True;
47 }
48
49
50
51 static struct idmap_methods *get_methods(const char *name)
52 {
53         int i = 0;
54         struct idmap_methods *ret = NULL;
55
56         while (remote_idmap_functions[i].name && strcmp(remote_idmap_functions[i].name, name)) {
57                 i++;
58         }
59
60         if (remote_idmap_functions[i].name) {
61
62                 if (!remote_idmap_functions[i].methods) {
63                         remote_idmap_functions[i].reg_meth(&remote_idmap_functions[i].methods);
64                 }
65
66                 ret = remote_idmap_functions[i].methods;
67         }
68
69         return ret;
70 }
71
72 /* Initialize backend */
73 BOOL idmap_init(void)
74 {
75         const char *remote_backend = lp_idmap_backend();
76
77         if (!local_map) {
78                 idmap_reg_tdb(&local_map);
79                 if (NT_STATUS_IS_ERR(local_map->init())) {
80                         DEBUG(0, ("idmap_init: could not load or create local backend!\n"));
81                         return False;
82                 }
83         }
84         
85         if (!remote_map && remote_backend && *remote_backend != 0) {
86                 DEBUG(3, ("idmap_init: using '%s' as remote backend\n", remote_backend));
87                 
88                 remote_map = get_methods(remote_backend);
89                 if (!remote_map) {
90                         DEBUG(0, ("idmap_init: could not load remote backend '%s'\n", remote_backend));
91                         return False;
92                 }
93                 remote_map->init();
94         }
95
96         return True;
97 }
98
99 NTSTATUS idmap_set_mapping(const DOM_SID *sid, unid_t id, int id_type)
100 {
101         NTSTATUS ret;
102
103         lazy_initialize_idmap();
104
105         ret = local_map->set_mapping(sid, id, id_type);
106         if (NT_STATUS_IS_ERR(ret)) {
107                 DEBUG (0, ("idmap_set_mapping: Error, unable to modify local cache!\n"));
108                 DEBUGADD(0, ("Error: %s", nt_errstr(ret)));
109                 return ret;
110         }
111
112         /* Being able to update the remote cache is seldomly right.
113            Generally this is a forbidden operation. */
114         if (!(id_type & ID_CACHE) && (remote_map != NULL)) {
115                 remote_map->set_mapping(sid, id, id_type);
116                 if (NT_STATUS_IS_ERR(ret)) {
117                         DEBUG (0, ("idmap_set_mapping: Error, unable to modify remote cache!\n"));
118                         DEBUGADD(0, ("Error: %s", nt_errstr(ret)));
119                 }
120         }
121
122         return ret;
123 }
124
125 /* Get ID from SID */
126 NTSTATUS idmap_get_id_from_sid(unid_t *id, int *id_type, const DOM_SID *sid)
127 {
128         NTSTATUS ret;
129         int loc_type;
130
131         lazy_initialize_idmap();
132
133         loc_type = *id_type;
134         if (remote_map) { /* We have a central remote idmap */
135                 loc_type |= ID_NOMAP;
136         }
137         ret = local_map->get_id_from_sid(id, &loc_type, sid);
138         if (NT_STATUS_IS_ERR(ret)) {
139                 if (remote_map) {
140                         ret = remote_map->get_id_from_sid(id, id_type, sid);
141                         if (NT_STATUS_IS_ERR(ret)) {
142                                 DEBUG(3, ("idmap_get_id_from_sid: error fetching id!\n"));
143                                 return ret;
144                         } else {
145                                 loc_type |= ID_CACHE;
146                                 idmap_set_mapping(sid, *id, loc_type);
147                         }
148                 }
149         } else {
150                 *id_type = loc_type & ID_TYPEMASK;
151         }
152
153         return ret;
154 }
155
156 /* Get SID from ID */
157 NTSTATUS idmap_get_sid_from_id(DOM_SID *sid, unid_t id, int id_type)
158 {
159         NTSTATUS ret;
160         int loc_type;
161
162         lazy_initialize_idmap();
163
164         loc_type = id_type;
165         if (remote_map) {
166                 loc_type = id_type | ID_NOMAP;
167         }
168         ret = local_map->get_sid_from_id(sid, id, loc_type);
169         if (NT_STATUS_IS_ERR(ret)) {
170                 if (remote_map) {
171                         ret = remote_map->get_sid_from_id(sid, id, id_type);
172                         if (NT_STATUS_IS_ERR(ret)) {
173                                 DEBUG(3, ("idmap_get_sid_from_id: unable to fetch sid!\n"));
174                                 return ret;
175                         } else {
176                                 loc_type |= ID_CACHE;
177                                 idmap_set_mapping(sid, id, loc_type);
178                         }
179                 }
180         }
181
182         return ret;
183 }
184
185 /* Close backend */
186 NTSTATUS idmap_close(void)
187 {
188         NTSTATUS ret;
189
190         ret = local_map->close();
191         if (NT_STATUS_IS_ERR(ret)) {
192                 DEBUG(3, ("idmap_close: failed to close local cache!\n"));
193         }
194
195         if (remote_map) {
196                 ret = remote_map->close();
197                 if (NT_STATUS_IS_ERR(ret)) {
198                         DEBUG(3, ("idmap_close: failed to close remote idmap repository!\n"));
199                 }
200         }
201
202         return ret;
203 }
204
205 /* Dump backend status */
206 void idmap_status(void)
207 {
208         lazy_initialize_idmap();
209
210         local_map->status();
211         if (remote_map) remote_map->status();
212 }