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 }