namemap_cache: Absorb the expired calculation into namemap_cache.c
[nivanova/samba-autobuild/.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
57         ret = strv_add(talloc_tos(), &val, domain);
58         if (ret != 0) {
59                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
60                 goto fail;
61         }
62         ret = strv_add(NULL, &val, name);
63         if (ret != 0) {
64                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
65                 goto fail;
66         }
67         ret = strv_add(NULL, &val, typebuf);
68         if (ret != 0) {
69                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
70                 goto fail;
71         }
72
73         dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
74         snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf);
75
76         data = data_blob_const(val, talloc_get_size(val));
77
78         ok = gencache_set_data_blob(keybuf, data, timeout);
79         if (!ok) {
80                 DBG_DEBUG("gencache_set_data_blob failed\n");
81         }
82 fail:
83         TALLOC_FREE(val);
84         return ok;
85 }
86
87 struct namemap_cache_find_sid_state {
88         void (*fn)(const char *domain,
89                    const char *name,
90                    enum lsa_SidType type,
91                    bool expired,
92                    void *private_data);
93         void *private_data;
94         bool ok;
95 };
96
97 static void namemap_cache_find_sid_parser(time_t timeout, DATA_BLOB blob,
98                                           void *private_data)
99 {
100         struct namemap_cache_find_sid_state *state = private_data;
101         const char *strv = (const char *)blob.data;
102         size_t strv_len = blob.length;
103         const char *domain;
104         const char *name;
105         const char *typebuf;
106         char *endptr;
107         unsigned long type;
108
109         state->ok = false;
110
111         domain = strv_len_next(strv, strv_len, NULL);
112         if (domain == NULL) {
113                 return;
114         }
115         name = strv_len_next(strv, strv_len, domain);
116         if (name == NULL) {
117                 return;
118         }
119         typebuf = strv_len_next(strv, strv_len, name);
120         if (typebuf == NULL) {
121                 return;
122         }
123
124         type = strtoul(typebuf, &endptr, 10);
125         if (*endptr != '\0') {
126                 return;
127         }
128         if ((type == ULONG_MAX) && (errno == ERANGE)) {
129                 return;
130         }
131
132         state->fn(domain,
133                   name,
134                   (enum lsa_SidType)type,
135                   timeout <= time(NULL),
136                   state->private_data);
137
138         state->ok = true;
139 }
140
141 bool namemap_cache_find_sid(const struct dom_sid *sid,
142                             void (*fn)(const char *domain,
143                                        const char *name,
144                                        enum lsa_SidType type,
145                                        bool expired,
146                                        void *private_data),
147                             void *private_data)
148 {
149         struct namemap_cache_find_sid_state state = {
150                 .fn = fn, .private_data = private_data
151         };
152         char sidbuf[DOM_SID_STR_BUFLEN];
153         char keybuf[DOM_SID_STR_BUFLEN+10];
154         bool ok;
155
156         dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
157         snprintf(keybuf, sizeof(keybuf), "SID2NAME/%s", sidbuf);
158
159         ok = gencache_parse(keybuf, namemap_cache_find_sid_parser, &state);
160         if (!ok) {
161                 DBG_DEBUG("gencache_parse(%s) failed\n", keybuf);
162                 return false;
163         }
164
165         if (!state.ok) {
166                 DBG_DEBUG("Could not parse %s, deleting\n", keybuf);
167                 gencache_del(keybuf);
168                 return false;
169         }
170
171         return true;
172 }
173
174 bool namemap_cache_set_name2sid(const char *domain, const char *name,
175                                 const struct dom_sid *sid,
176                                 enum lsa_SidType type,
177                                 time_t timeout)
178 {
179         char typebuf[16];
180         char sidbuf[DOM_SID_STR_BUFLEN];
181         char *key;
182         char *key_upper;
183         char *val = NULL;
184         DATA_BLOB data;
185         int ret;
186         bool ok = false;
187
188         if (domain == NULL) {
189                 domain = "";
190         }
191         if (name == NULL) {
192                 name = "";
193         }
194         if (type == SID_NAME_UNKNOWN) {
195                 sidbuf[0] = '\0';
196         } else {
197                 dom_sid_string_buf(sid, sidbuf, sizeof(sidbuf));
198         }
199
200         snprintf(typebuf, sizeof(typebuf), "%d", (int)type);
201
202         key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
203         if (key == NULL) {
204                 DBG_DEBUG("talloc_asprintf failed\n");
205                 goto fail;
206         }
207         key_upper = strupper_talloc(key, key);
208         if (key_upper == NULL) {
209                 DBG_DEBUG("strupper_talloc failed\n");
210                 goto fail;
211         }
212
213         ret = strv_add(key, &val, sidbuf);
214         if (ret != 0) {
215                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
216                 goto fail;
217         }
218         ret = strv_add(NULL, &val, typebuf);
219         if (ret != 0) {
220                 DBG_DEBUG("strv_add failed: %s\n", strerror(ret));
221                 goto fail;
222         }
223
224         data = data_blob_const(val, talloc_get_size(val));
225
226         ok = gencache_set_data_blob(key_upper, data, timeout);
227         if (!ok) {
228                 DBG_DEBUG("gencache_set_data_blob failed\n");
229         }
230 fail:
231         TALLOC_FREE(key);
232         return ok;
233 }
234
235 struct namemap_cache_find_name_state {
236         void (*fn)(const struct dom_sid *sid,
237                    enum lsa_SidType type,
238                    bool expired,
239                    void *private_data);
240         void *private_data;
241         bool ok;
242 };
243
244 static void namemap_cache_find_name_parser(time_t timeout, DATA_BLOB blob,
245                                            void *private_data)
246 {
247         struct namemap_cache_find_name_state *state = private_data;
248         const char *strv = (const char *)blob.data;
249         size_t strv_len = blob.length;
250         const char *sidbuf;
251         const char *sid_endptr;
252         const char *typebuf;
253         char *endptr;
254         struct dom_sid sid;
255         unsigned long type;
256         bool ok;
257
258         state->ok = false;
259
260         sidbuf = strv_len_next(strv, strv_len, NULL);
261         if (sidbuf == NULL) {
262                 return;
263         }
264         typebuf = strv_len_next(strv, strv_len, sidbuf);
265         if (typebuf == NULL) {
266                 return;
267         }
268
269         ok = dom_sid_parse_endp(sidbuf, &sid, &sid_endptr);
270         if (!ok) {
271                 return;
272         }
273         if (*sid_endptr != '\0') {
274                 return;
275         }
276
277         type = strtoul(typebuf, &endptr, 10);
278         if (*endptr != '\0') {
279                 return;
280         }
281         if ((type == ULONG_MAX) && (errno == ERANGE)) {
282                 return;
283         }
284
285         state->fn(&sid,
286                   (enum lsa_SidType)type,
287                   timeout <= time(NULL),
288                   state->private_data);
289
290         state->ok = true;
291 }
292
293 bool namemap_cache_find_name(const char *domain,
294                              const char *name,
295                              void (*fn)(const struct dom_sid *sid,
296                                         enum lsa_SidType type,
297                                         bool expired,
298                                         void *private_data),
299                              void *private_data)
300 {
301         struct namemap_cache_find_name_state state = {
302                 .fn = fn, .private_data = private_data
303         };
304         char *key;
305         char *key_upper;
306         bool ret = false;
307         bool ok;
308
309         key = talloc_asprintf(talloc_tos(), "NAME2SID/%s\\%s", domain, name);
310         if (key == NULL) {
311                 DBG_DEBUG("talloc_asprintf failed\n");
312                 return false;
313         }
314         key_upper = strupper_talloc(key, key);
315         if (key_upper == NULL) {
316                 DBG_DEBUG("strupper_talloc failed\n");
317                 goto fail;
318         }
319
320         ok = gencache_parse(key_upper, namemap_cache_find_name_parser, &state);
321         if (!ok) {
322                 DBG_DEBUG("gencache_parse(%s) failed\n", key_upper);
323                 goto fail;
324         }
325
326         if (!state.ok) {
327                 DBG_DEBUG("Could not parse %s, deleting\n", key_upper);
328                 goto fail;
329         }
330
331         ret = true;
332 fail:
333         TALLOC_FREE(key);
334         return ret;
335 }