lib: Add namemap_cache
[samba.git] / source3 / lib / namemap_cache.c
1 /*
2  * Unix SMB/CIFS implementation.
3  * Utils for caching sid2name and name2sid
4  * Copyright (C) Volker Lendecke 2017
5  *
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.
10  *
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.
15  *
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/>.
18  */
19
20 #include "replace.h"
21 #include "namemap_cache.h"
22 #include "source3/lib/gencache.h"
23 #include "lib/util/debug.h"
24 #include "lib/util/strv.h"
25 #include "lib/util/talloc_stack.h"
26 #include "lib/util/charset/charset.h"
27 #include "libcli/security/dom_sid.h"
28
29 bool namemap_cache_set_sid2name(const struct dom_sid *sid,
30                                 const char *domain, const char *name,
31                                 enum lsa_SidType type, time_t timeout)
32 {
33         char typebuf[16];
34         char sidbuf[DOM_SID_STR_BUFLEN];
35         char keybuf[DOM_SID_STR_BUFLEN+10];
36         char *val = NULL;
37         DATA_BLOB data;
38         int ret;
39         bool ok = false;
40
41         if ((sid == NULL) || is_null_sid(sid)) {
42                 return true;
43         }
44         if (domain == NULL) {
45                 domain = "";
46         }
47         if (name == NULL) {
48                 name = "";
49         }
50         if (type == SID_NAME_UNKNOWN) {
51                 domain = "";
52                 name = "";
53         }
54
55         snprintf(typebuf, sizeof(typebuf), "%d", (int)type);
56         snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf);
57
58         ret = strv_add(talloc_tos(), &val, domain);
59         if (ret != 0) {
60                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
61                 goto fail;
62         }
63         ret = strv_add(NULL, &val, name);
64         if (ret != 0) {
65                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
66                 goto fail;
67         }
68         ret = strv_add(NULL, &val, typebuf);
69         if (ret != 0) {
70                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
71                 goto fail;
72         }
73
74         dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
75         snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf);
76
77         data = data_blob_const(val, talloc_get_size(val));
78
79         ok = gencache_set_data_blob(keybuf, data, timeout);
80         if (!ok) {
81                 DBG_DEBUG("gencache_set_data_blob failed\n");
82         }
83 fail:
84         TALLOC_FREE(val);
85         return ok;
86 }
87
88 struct namemap_cache_find_sid_state {
89         void (*fn)(const char *domain, const char *name,
90                    enum lsa_SidType type, time_t timeout,
91                    void *private_data);
92         void *private_data;
93         bool ok;
94 };
95
96 static void namemap_cache_find_sid_parser(time_t timeout, DATA_BLOB blob,
97                                           void *private_data)
98 {
99         struct namemap_cache_find_sid_state *state = private_data;
100         const char *strv = (const char *)blob.data;
101         size_t strv_len = blob.length;
102         const char *domain;
103         const char *name;
104         const char *typebuf;
105         char *endptr;
106         unsigned long type;
107
108         state->ok = false;
109
110         domain = strv_len_next(strv, strv_len, NULL);
111         if (domain == NULL) {
112                 return;
113         }
114         name = strv_len_next(strv, strv_len, domain);
115         if (name == NULL) {
116                 return;
117         }
118         typebuf = strv_len_next(strv, strv_len, name);
119         if (typebuf == NULL) {
120                 return;
121         }
122
123         type = strtoul(typebuf, &endptr, 10);
124         if (*endptr != '\0') {
125                 return;
126         }
127         if ((type == ULONG_MAX) && (errno == ERANGE)) {
128                 return;
129         }
130
131         state->fn(domain, name, (enum lsa_SidType)type, timeout,
132                   state->private_data);
133
134         state->ok = true;
135 }
136
137 bool namemap_cache_find_sid(const struct dom_sid *sid,
138                             void (*fn)(const char *domain, const char *name,
139                                        enum lsa_SidType type, time_t timeout,
140                                        void *private_data),
141                             void *private_data)
142 {
143         struct namemap_cache_find_sid_state state = {
144                 .fn = fn, .private_data = private_data
145         };
146         char sidbuf[DOM_SID_STR_BUFLEN];
147         char keybuf[DOM_SID_STR_BUFLEN+10];
148         bool ok;
149
150         dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
151         snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf);
152
153         ok = gencache_parse(keybuf, namemap_cache_find_sid_parser, &state);
154         if (!ok) {
155                 DBG_DEBUG("gencache_parse(%s) failed\n", keybuf);
156                 return false;
157         }
158
159         if (!state.ok) {
160                 DBG_DEBUG("Could not parse %s, deleting\n", keybuf);
161                 gencache_del(keybuf);
162                 return false;
163         }
164
165         return true;
166 }
167
168 bool namemap_cache_set_name2sid(const char *domain, const char *name,
169                                 const struct dom_sid *sid,
170                                 enum lsa_SidType type,
171                                 time_t timeout)
172 {
173         char typebuf[16];
174         char sidbuf[DOM_SID_STR_BUFLEN];
175         char *key;
176         char *key_upper;
177         char *val = NULL;
178         DATA_BLOB data;
179         int ret;
180         bool ok = false;
181
182         if (domain == NULL) {
183                 domain = "";
184         }
185         if (name == NULL) {
186                 name = "";
187         }
188         if (type == SID_NAME_UNKNOWN) {
189                 sidbuf[0] = '\0';
190         } else {
191                 dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
192         }
193
194         snprintf(typebuf, sizeof(typebuf), "%d", (int)type);
195
196         key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
197         if (key == NULL) {
198                 DBG_DEBUG("talloc_asprintf failed\n");
199                 goto fail;
200         }
201         key_upper = strupper_talloc(key, key);
202         if (key_upper == NULL) {
203                 DBG_DEBUG("strupper_talloc failed\n");
204                 goto fail;
205         }
206
207         ret = strv_add(key, &val, sidbuf);
208         if (ret != 0) {
209                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
210                 goto fail;
211         }
212         ret = strv_add(NULL, &val, typebuf);
213         if (ret != 0) {
214                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
215                 goto fail;
216         }
217
218         data = data_blob_const(val, talloc_get_size(val));
219
220         ok = gencache_set_data_blob(key_upper, data, timeout);
221         if (!ok) {
222                 DBG_DEBUG("gencache_set_data_blob failed\n");
223         }
224 fail:
225         TALLOC_FREE(key);
226         return ok;
227 }
228
229 struct namemap_cache_find_name_state {
230         void (*fn)(const struct dom_sid *sid,
231                    enum lsa_SidType type, time_t timeout,
232                    void *private_data);
233         void *private_data;
234         bool ok;
235 };
236
237 static void namemap_cache_find_name_parser(time_t timeout, DATA_BLOB blob,
238                                            void *private_data)
239 {
240         struct namemap_cache_find_name_state *state = private_data;
241         const char *strv = (const char *)blob.data;
242         size_t strv_len = blob.length;
243         const char *sidbuf;
244         const char *sid_endptr;
245         const char *typebuf;
246         char *endptr;
247         struct dom_sid sid;
248         unsigned long type;
249         bool ok;
250
251         state->ok = false;
252
253         sidbuf = strv_len_next(strv, strv_len, NULL);
254         if (sidbuf == NULL) {
255                 return;
256         }
257         typebuf = strv_len_next(strv, strv_len, sidbuf);
258         if (typebuf == NULL) {
259                 return;
260         }
261
262         ok = dom_sid_parse_endp(sidbuf, &sid, &sid_endptr);
263         if (!ok) {
264                 return;
265         }
266         if (*sid_endptr != '\0') {
267                 return;
268         }
269
270         type = strtoul(typebuf, &endptr, 10);
271         if (*endptr != '\0') {
272                 return;
273         }
274         if ((type == ULONG_MAX) && (errno == ERANGE)) {
275                 return;
276         }
277
278         state->fn(&sid, (enum lsa_SidType)type, timeout, state->private_data);
279
280         state->ok = true;
281 }
282
283 bool namemap_cache_find_name(const char *domain, const char *name,
284                              void (*fn)(const struct dom_sid *sid,
285                                         enum lsa_SidType type, time_t timeout,
286                                         void *private_data),
287                              void *private_data)
288 {
289         struct namemap_cache_find_name_state state = {
290                 .fn = fn, .private_data = private_data
291         };
292         char *key;
293         char *key_upper;
294         bool ret = false;
295         bool ok;
296
297         key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
298         if (key == NULL) {
299                 DBG_DEBUG("talloc_asprintf failed\n");
300                 return false;
301         }
302         key_upper = strupper_talloc(key, key);
303         if (key_upper == NULL) {
304                 DBG_DEBUG("strupper_talloc failed\n");
305                 goto fail;
306         }
307
308         ok = gencache_parse(key_upper, namemap_cache_find_name_parser, &state);
309         if (!ok) {
310                 DBG_DEBUG("gencache_parse(%s) failed\n", key_upper);
311                 goto fail;
312         }
313
314         if (!state.ok) {
315                 DBG_DEBUG("Could not parse %s, deleting\n", key_upper);
316                 goto fail;
317         }
318
319         ret = true;
320 fail:
321         TALLOC_FREE(key);
322         return ret;
323 }