source/nsswitch/winbindd_cache.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Winbind cache backend functions
   5
   6    Copyright (C) Andrew Tridgell 2001
   7    Copyright (C) Gerald Carter   2003
   8
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24
  25 #include "includes.h"
  26 #include "winbindd.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_WINBIND
  30
  31 struct winbind_cache {
  32         TDB_CONTEXT *tdb;
  33 };
  34
  35 struct cache_entry {
  36         NTSTATUS status;
  37         uint32 sequence_number;
  38         uint8 *data;
  39         uint32 len, ofs;
  40 };
  41
  42 #define WINBINDD_MAX_CACHE_SIZE (50*1024*1024)
  43
  44 static struct winbind_cache *wcache;
  45
  46 /* flush the cache */
  47 void wcache_flush_cache(void)
  48 {
  49         extern BOOL opt_nocache;
  50
  51         if (!wcache)
  52                 return;
  53         if (wcache->tdb) {
  54                 tdb_close(wcache->tdb);
  55                 wcache->tdb = NULL;
  56         }
  57         if (opt_nocache)
  58                 return;
  59
  60         wcache->tdb = tdb_open_log(lock_path("winbindd_cache.tdb"), 5000,
  61                                    TDB_CLEAR_IF_FIRST, O_RDWR|O_CREAT, 0600);
  62
  63         if (!wcache->tdb) {
  64                 DEBUG(0,("Failed to open winbindd_cache.tdb!\n"));
  65         }
  66         DEBUG(10,("wcache_flush_cache success\n"));
  67 }
  68
  69 void winbindd_check_cache_size(time_t t)
  70 {
  71         static time_t last_check_time;
  72         struct stat st;
  73
  74         if (last_check_time == (time_t)0)
  75                 last_check_time = t;
  76
  77         if (t - last_check_time < 60 && t - last_check_time > 0)
  78                 return;
  79
  80         if (wcache == NULL || wcache->tdb == NULL) {
  81                 DEBUG(0, ("Unable to check size of tdb cache - cache not open !\n"));
  82                 return;
  83         }
  84
  85         if (fstat(wcache->tdb->fd, &st) == -1) {
  86                 DEBUG(0, ("Unable to check size of tdb cache %s!\n", strerror(errno) ));
  87                 return;
  88         }
  89
  90         if (st.st_size > WINBINDD_MAX_CACHE_SIZE) {
  91                 DEBUG(10,("flushing cache due to size (%lu) > (%lu)\n",
  92                         (unsigned long)st.st_size,
  93                         (unsigned long)WINBINDD_MAX_CACHE_SIZE));
  94                 wcache_flush_cache();
  95         }
  96 }
  97
  98 /* get the winbind_cache structure */
  99 static struct winbind_cache *get_cache(struct winbindd_domain *domain)
 100 {
 101         struct winbind_cache *ret = wcache;
 102
 103         if (!domain->backend) {
 104                 extern struct winbindd_methods msrpc_methods;
 105                 switch (lp_security()) {
 106 #ifdef HAVE_ADS
 107                 case SEC_ADS: {
 108                         extern struct winbindd_methods ads_methods;
 109                         /* always obey the lp_security parameter for our domain */
 110                         if (domain->primary) {
 111                                 domain->backend = &ads_methods;
 112                                 break;
 113                         }
 114
 115                         /* only use ADS for native modes at the momment.
 116                            The problem is the correct detection of mixed
 117                            mode domains from NT4 BDC's    --jerry */
 118
 119                         if ( domain->native_mode ) {
 120                                 DEBUG(5,("get_cache: Setting ADS methods for domain %s\n",
 121                                         domain->name));
 122                                 domain->backend = &ads_methods;
 123                                 break;
 124                         }
 125
 126                         /* fall through */
 127                 }
 128 #endif
 129                 default:
 130                         DEBUG(5,("get_cache: Setting MS-RPC methods for domain %s\n",
 131                                 domain->name));
 132                         domain->backend = &msrpc_methods;
 133                 }
 134         }
 135
 136         if (ret)
 137                 return ret;
 138
 139         ret = SMB_XMALLOC_P(struct winbind_cache);
 140         ZERO_STRUCTP(ret);
 141
 142         wcache = ret;
 143         wcache_flush_cache();
 144
 145         return ret;
 146 }
 147
 148 /*
 149   free a centry structure
 150 */
 151 static void centry_free(struct cache_entry *centry)
 152 {
 153         if (!centry)
 154                 return;
 155         SAFE_FREE(centry->data);
 156         free(centry);
 157 }
 158
 159 /*
 160   pull a uint32 from a cache entry
 161 */
 162 static uint32 centry_uint32(struct cache_entry *centry)
 163 {
 164         uint32 ret;
 165         if (centry->len - centry->ofs < 4) {
 166                 DEBUG(0,("centry corruption? needed 4 bytes, have %d\n",
 167                          centry->len - centry->ofs));
 168                 smb_panic("centry_uint32");
 169         }
 170         ret = IVAL(centry->data, centry->ofs);
 171         centry->ofs += 4;
 172         return ret;
 173 }
 174
 175 /*
 176   pull a uint8 from a cache entry
 177 */
 178 static uint8 centry_uint8(struct cache_entry *centry)
 179 {
 180         uint8 ret;
 181         if (centry->len - centry->ofs < 1) {
 182                 DEBUG(0,("centry corruption? needed 1 bytes, have %d\n",
 183                          centry->len - centry->ofs));
 184                 smb_panic("centry_uint32");
 185         }
 186         ret = CVAL(centry->data, centry->ofs);
 187         centry->ofs += 1;
 188         return ret;
 189 }
 190
 191 /* pull a string from a cache entry, using the supplied
 192    talloc context
 193 */
 194 static char *centry_string(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
 195 {
 196         uint32 len;
 197         char *ret;
 198
 199         len = centry_uint8(centry);
 200
 201         if (len == 0xFF) {
 202                 /* a deliberate NULL string */
 203                 return NULL;
 204         }
 205
 206         if (centry->len - centry->ofs < len) {
 207                 DEBUG(0,("centry corruption? needed %d bytes, have %d\n",
 208                          len, centry->len - centry->ofs));
 209                 smb_panic("centry_string");
 210         }
 211
 212         ret = TALLOC(mem_ctx, len+1);
 213         if (!ret) {
 214                 smb_panic("centry_string out of memory\n");
 215         }
 216         memcpy(ret,centry->data + centry->ofs, len);
 217         ret[len] = 0;
 218         centry->ofs += len;
 219         return ret;
 220 }
 221
 222 /* pull a string from a cache entry, using the supplied
 223    talloc context
 224 */
 225 static DOM_SID *centry_sid(struct cache_entry *centry, TALLOC_CTX *mem_ctx)
 226 {
 227         DOM_SID *sid;
 228         char *sid_string;
 229
 230         sid = TALLOC_P(mem_ctx, DOM_SID);
 231         if (!sid)
 232                 return NULL;
 233
 234         sid_string = centry_string(centry, mem_ctx);
 235         if (!string_to_sid(sid, sid_string)) {
 236                 return NULL;
 237         }
 238         return sid;
 239 }
 240
 241 /* the server is considered down if it can't give us a sequence number */
 242 static BOOL wcache_server_down(struct winbindd_domain *domain)
 243 {
 244         BOOL ret;
 245
 246         if (!wcache->tdb)
 247                 return False;
 248
 249         ret = (domain->sequence_number == DOM_SEQUENCE_NONE);
 250
 251         if (ret)
 252                 DEBUG(10,("wcache_server_down: server for Domain %s down\n",
 253                         domain->name ));
 254         return ret;
 255 }
 256
 257 static NTSTATUS fetch_cache_seqnum( struct winbindd_domain *domain, time_t now )
 258 {
 259         TDB_DATA data;
 260         fstring key;
 261         uint32 time_diff;
 262
 263         if (!wcache->tdb) {
 264                 DEBUG(10,("fetch_cache_seqnum: tdb == NULL\n"));
 265                 return NT_STATUS_UNSUCCESSFUL;
 266         }
 267
 268         fstr_sprintf( key, "SEQNUM/%s", domain->name );
 269
 270         data = tdb_fetch_bystring( wcache->tdb, key );
 271         if ( !data.dptr || data.dsize!=8 ) {
 272                 DEBUG(10,("fetch_cache_seqnum: invalid data size key [%s]\n", key ));
 273                 return NT_STATUS_UNSUCCESSFUL;
 274         }
 275
 276         domain->sequence_number = IVAL(data.dptr, 0);
 277         domain->last_seq_check  = IVAL(data.dptr, 4);
 278
 279         SAFE_FREE(data.dptr);
 280
 281         /* have we expired? */
 282
 283         time_diff = now - domain->last_seq_check;
 284         if ( time_diff > lp_winbind_cache_time() ) {
 285                 DEBUG(10,("fetch_cache_seqnum: timeout [%s][%u @ %u]\n",
 286                         domain->name, domain->sequence_number,
 287                         (uint32)domain->last_seq_check));
 288                 return NT_STATUS_UNSUCCESSFUL;
 289         }
 290
 291         DEBUG(10,("fetch_cache_seqnum: success [%s][%u @ %u]\n",
 292                 domain->name, domain->sequence_number,
 293                 (uint32)domain->last_seq_check));
 294
 295         return NT_STATUS_OK;
 296 }
 297
 298 static NTSTATUS store_cache_seqnum( struct winbindd_domain *domain )
 299 {
 300         TDB_DATA data, key;
 301         fstring key_str;
 302         char buf[8];
 303
 304         if (!wcache->tdb) {
 305                 DEBUG(10,("store_cache_seqnum: tdb == NULL\n"));
 306                 return NT_STATUS_UNSUCCESSFUL;
 307         }
 308
 309         fstr_sprintf( key_str, "SEQNUM/%s", domain->name );
 310         key.dptr = key_str;
 311         key.dsize = strlen(key_str)+1;
 312
 313         SIVAL(buf, 0, domain->sequence_number);
 314         SIVAL(buf, 4, domain->last_seq_check);
 315         data.dptr = buf;
 316         data.dsize = 8;
 317
 318         if ( tdb_store( wcache->tdb, key, data, TDB_REPLACE) == -1 ) {
 319                 DEBUG(10,("store_cache_seqnum: tdb_store fail key [%s]\n", key_str ));
 320                 return NT_STATUS_UNSUCCESSFUL;
 321         }
 322
 323         DEBUG(10,("store_cache_seqnum: success [%s][%u @ %u]\n",
 324                 domain->name, domain->sequence_number,
 325                 (uint32)domain->last_seq_check));
 326
 327         return NT_STATUS_OK;
 328 }
 329
 330 /*
 331   refresh the domain sequence number. If force is True
 332   then always refresh it, no matter how recently we fetched it
 333 */
 334
 335 static void refresh_sequence_number(struct winbindd_domain *domain, BOOL force)
 336 {
 337         NTSTATUS status;
 338         unsigned time_diff;
 339         time_t t = time(NULL);
 340         unsigned cache_time = lp_winbind_cache_time();
 341
 342         get_cache( domain );
 343
 344 #if 0   /* JERRY -- disable as the default cache time is now 5 minutes */
 345         /* trying to reconnect is expensive, don't do it too often */
 346         if (domain->sequence_number == DOM_SEQUENCE_NONE) {
 347                 cache_time *= 8;
 348         }
 349 #endif
 350
 351         time_diff = t - domain->last_seq_check;
 352
 353         /* see if we have to refetch the domain sequence number */
 354         if (!force && (time_diff < cache_time)) {
 355                 DEBUG(10, ("refresh_sequence_number: %s time ok\n", domain->name));
 356                 goto done;
 357         }
 358
 359         /* try to get the sequence number from the tdb cache first */
 360         /* this will update the timestamp as well */
 361
 362         status = fetch_cache_seqnum( domain, t );
 363         if ( NT_STATUS_IS_OK(status) )
 364                 goto done;
 365
 366         /* important! make sure that we know if this is a native
 367            mode domain or not */
 368
 369         if ( !domain->initialized )
 370                 set_dc_type_and_flags( domain );
 371
 372         status = domain->backend->sequence_number(domain, &domain->sequence_number);
 373
 374         if (!NT_STATUS_IS_OK(status)) {
 375                 domain->sequence_number = DOM_SEQUENCE_NONE;
 376         }
 377
 378         domain->last_status = status;
 379         domain->last_seq_check = time(NULL);
 380
 381         /* save the new sequence number ni the cache */
 382         store_cache_seqnum( domain );
 383
 384 done:
 385         DEBUG(10, ("refresh_sequence_number: %s seq number is now %d\n",
 386                    domain->name, domain->sequence_number));
 387
 388         return;
 389 }
 390
 391 /*
 392   decide if a cache entry has expired
 393 */
 394 static BOOL centry_expired(struct winbindd_domain *domain, const char *keystr, struct cache_entry *centry)
 395 {
 396         /* if the server is OK and our cache entry came from when it was down then
 397            the entry is invalid */
 398         if (domain->sequence_number != DOM_SEQUENCE_NONE &&
 399             centry->sequence_number == DOM_SEQUENCE_NONE) {
 400                 DEBUG(10,("centry_expired: Key %s for domain %s invalid sequence.\n",
 401                         keystr, domain->name ));
 402                 return True;
 403         }
 404
 405         /* if the server is down or the cache entry is not older than the
 406            current sequence number then it is OK */
 407         if (wcache_server_down(domain) ||
 408             centry->sequence_number == domain->sequence_number) {
 409                 DEBUG(10,("centry_expired: Key %s for domain %s is good.\n",
 410                         keystr, domain->name ));
 411                 return False;
 412         }
 413
 414         DEBUG(10,("centry_expired: Key %s for domain %s expired\n",
 415                 keystr, domain->name ));
 416
 417         /* it's expired */
 418         return True;
 419 }
 420
 421 /*
 422   fetch an entry from the cache, with a varargs key. auto-fetch the sequence
 423   number and return status
 424 */
 425 static struct cache_entry *wcache_fetch(struct winbind_cache *cache,
 426                                         struct winbindd_domain *domain,
 427                                         const char *format, ...) PRINTF_ATTRIBUTE(3,4);
 428 static struct cache_entry *wcache_fetch(struct winbind_cache *cache,
 429                                         struct winbindd_domain *domain,
 430                                         const char *format, ...)
 431 {
 432         va_list ap;
 433         char *kstr;
 434         TDB_DATA data;
 435         struct cache_entry *centry;
 436         TDB_DATA key;
 437
 438         refresh_sequence_number(domain, False);
 439
 440         va_start(ap, format);
 441         smb_xvasprintf(&kstr, format, ap);
 442         va_end(ap);
 443
 444         key.dptr = kstr;
 445         key.dsize = strlen(kstr);
 446         data = tdb_fetch(wcache->tdb, key);
 447         if (!data.dptr) {
 448                 /* a cache miss */
 449                 free(kstr);
 450                 return NULL;
 451         }
 452
 453         centry = SMB_XMALLOC_P(struct cache_entry);
 454         centry->data = (unsigned char *)data.dptr;
 455         centry->len = data.dsize;
 456         centry->ofs = 0;
 457
 458         if (centry->len < 8) {
 459                 /* huh? corrupt cache? */
 460                 DEBUG(10,("wcache_fetch: Corrupt cache for key %s domain %s (len < 8) ?\n",
 461                         kstr, domain->name ));
 462                 centry_free(centry);
 463                 free(kstr);
 464                 return NULL;
 465         }
 466
 467         centry->status = NT_STATUS(centry_uint32(centry));
 468         centry->sequence_number = centry_uint32(centry);
 469
 470         if (centry_expired(domain, kstr, centry)) {
 471                 extern BOOL opt_dual_daemon;
 472
 473                 DEBUG(10,("wcache_fetch: entry %s expired for domain %s\n",
 474                          kstr, domain->name ));
 475
 476                 if (opt_dual_daemon) {
 477                         extern BOOL background_process;
 478                         background_process = True;
 479                         DEBUG(10,("wcache_fetch: background processing expired entry %s for domain %s\n",
 480                                  kstr, domain->name ));
 481                 } else {
 482                         centry_free(centry);
 483                         free(kstr);
 484                         return NULL;
 485                 }
 486         }
 487
 488         DEBUG(10,("wcache_fetch: returning entry %s for domain %s\n",
 489                  kstr, domain->name ));
 490
 491         free(kstr);
 492         return centry;
 493 }
 494
 495 /*
 496   make sure we have at least len bytes available in a centry
 497 */
 498 static void centry_expand(struct cache_entry *centry, uint32 len)
 499 {
 500         uint8 *p;
 501         if (centry->len - centry->ofs >= len)
 502                 return;
 503         centry->len *= 2;
 504         p = SMB_REALLOC(centry->data, centry->len);
 505         if (!p) {
 506                 DEBUG(0,("out of memory: needed %d bytes in centry_expand\n", centry->len));
 507                 smb_panic("out of memory in centry_expand");
 508         }
 509         centry->data = p;
 510 }
 511
 512 /*
 513   push a uint32 into a centry
 514 */
 515 static void centry_put_uint32(struct cache_entry *centry, uint32 v)
 516 {
 517         centry_expand(centry, 4);
 518         SIVAL(centry->data, centry->ofs, v);
 519         centry->ofs += 4;
 520 }
 521
 522 /*
 523   push a uint8 into a centry
 524 */
 525 static void centry_put_uint8(struct cache_entry *centry, uint8 v)
 526 {
 527         centry_expand(centry, 1);
 528         SCVAL(centry->data, centry->ofs, v);
 529         centry->ofs += 1;
 530 }
 531
 532 /*
 533    push a string into a centry
 534  */
 535 static void centry_put_string(struct cache_entry *centry, const char *s)
 536 {
 537         int len;
 538
 539         if (!s) {
 540                 /* null strings are marked as len 0xFFFF */
 541                 centry_put_uint8(centry, 0xFF);
 542                 return;
 543         }
 544
 545         len = strlen(s);
 546         /* can't handle more than 254 char strings. Truncating is probably best */
 547         if (len > 254)
 548                 len = 254;
 549         centry_put_uint8(centry, len);
 550         centry_expand(centry, len);
 551         memcpy(centry->data + centry->ofs, s, len);
 552         centry->ofs += len;
 553 }
 554
 555 static void centry_put_sid(struct cache_entry *centry, const DOM_SID *sid)
 556 {
 557         fstring sid_string;
 558         centry_put_string(centry, sid_to_string(sid_string, sid));
 559 }
 560
 561 /*
 562   start a centry for output. When finished, call centry_end()
 563 */
 564 struct cache_entry *centry_start(struct winbindd_domain *domain, NTSTATUS status)
 565 {
 566         struct cache_entry *centry;
 567
 568         if (!wcache->tdb)
 569                 return NULL;
 570
 571         centry = SMB_XMALLOC_P(struct cache_entry);
 572
 573         centry->len = 8192; /* reasonable default */
 574         centry->data = SMB_XMALLOC_ARRAY(char, centry->len);
 575         centry->ofs = 0;
 576         centry->sequence_number = domain->sequence_number;
 577         centry_put_uint32(centry, NT_STATUS_V(status));
 578         centry_put_uint32(centry, centry->sequence_number);
 579         return centry;
 580 }
 581
 582 /*
 583   finish a centry and write it to the tdb
 584 */
 585 static void centry_end(struct cache_entry *centry, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 586 static void centry_end(struct cache_entry *centry, const char *format, ...)
 587 {
 588         va_list ap;
 589         char *kstr;
 590         TDB_DATA key, data;
 591
 592         va_start(ap, format);
 593         smb_xvasprintf(&kstr, format, ap);
 594         va_end(ap);
 595
 596         key.dptr = kstr;
 597         key.dsize = strlen(kstr);
 598         data.dptr = (char *)centry->data;
 599         data.dsize = centry->ofs;
 600
 601         tdb_store(wcache->tdb, key, data, TDB_REPLACE);
 602         free(kstr);
 603 }
 604
 605 static void wcache_save_name_to_sid(struct winbindd_domain *domain,
 606                                     NTSTATUS status, const char *domain_name,
 607                                     const char *name, const DOM_SID *sid,
 608                                     enum SID_NAME_USE type)
 609 {
 610         struct cache_entry *centry;
 611         fstring uname;
 612
 613         centry = centry_start(domain, status);
 614         if (!centry)
 615                 return;
 616         centry_put_uint32(centry, type);
 617         centry_put_sid(centry, sid);
 618         fstrcpy(uname, name);
 619         strupper_m(uname);
 620         centry_end(centry, "NS/%s/%s", domain_name, uname);
 621         DEBUG(10,("wcache_save_name_to_sid: %s -> %s\n", uname,
 622                   sid_string_static(sid)));
 623         centry_free(centry);
 624 }
 625
 626 static void wcache_save_sid_to_name(struct winbindd_domain *domain, NTSTATUS status,
 627                                     const DOM_SID *sid, const char *domain_name, const char *name, enum SID_NAME_USE type)
 628 {
 629         struct cache_entry *centry;
 630         fstring sid_string;
 631
 632         centry = centry_start(domain, status);
 633         if (!centry)
 634                 return;
 635         if (NT_STATUS_IS_OK(status)) {
 636                 centry_put_uint32(centry, type);
 637                 centry_put_string(centry, domain_name);
 638                 centry_put_string(centry, name);
 639         }
 640         centry_end(centry, "SN/%s", sid_to_string(sid_string, sid));
 641         DEBUG(10,("wcache_save_sid_to_name: %s -> %s\n", sid_string, name));
 642         centry_free(centry);
 643 }
 644
 645
 646 static void wcache_save_user(struct winbindd_domain *domain, NTSTATUS status, WINBIND_USERINFO *info)
 647 {
 648         struct cache_entry *centry;
 649         fstring sid_string;
 650
 651         centry = centry_start(domain, status);
 652         if (!centry)
 653                 return;
 654         centry_put_string(centry, info->acct_name);
 655         centry_put_string(centry, info->full_name);
 656         centry_put_sid(centry, info->user_sid);
 657         centry_put_sid(centry, info->group_sid);
 658         centry_end(centry, "U/%s", sid_to_string(sid_string, info->user_sid));
 659         DEBUG(10,("wcache_save_user: %s (acct_name %s)\n", sid_string, info->acct_name));
 660         centry_free(centry);
 661 }
 662
 663
 664 /* Query display info. This is the basic user list fn */
 665 static NTSTATUS query_user_list(struct winbindd_domain *domain,
 666                                 TALLOC_CTX *mem_ctx,
 667                                 uint32 *num_entries,
 668                                 WINBIND_USERINFO **info)
 669 {
 670         struct winbind_cache *cache = get_cache(domain);
 671         struct cache_entry *centry = NULL;
 672         NTSTATUS status;
 673         unsigned int i, retry;
 674
 675         if (!cache->tdb)
 676                 goto do_query;
 677
 678         centry = wcache_fetch(cache, domain, "UL/%s", domain->name);
 679         if (!centry)
 680                 goto do_query;
 681
 682         *num_entries = centry_uint32(centry);
 683
 684         if (*num_entries == 0)
 685                 goto do_cached;
 686
 687         (*info) = TALLOC_ARRAY(mem_ctx, WINBIND_USERINFO, *num_entries);
 688         if (! (*info))
 689                 smb_panic("query_user_list out of memory");
 690         for (i=0; i<(*num_entries); i++) {
 691                 (*info)[i].acct_name = centry_string(centry, mem_ctx);
 692                 (*info)[i].full_name = centry_string(centry, mem_ctx);
 693                 (*info)[i].user_sid = centry_sid(centry, mem_ctx);
 694                 (*info)[i].group_sid = centry_sid(centry, mem_ctx);
 695         }
 696
 697 do_cached:
 698         status = centry->status;
 699
 700         DEBUG(10,("query_user_list: [Cached] - cached list for domain %s status %s\n",
 701                 domain->name, get_friendly_nt_error_msg(status) ));
 702
 703         centry_free(centry);
 704         return status;
 705
 706 do_query:
 707         *num_entries = 0;
 708         *info = NULL;
 709
 710         /* Return status value returned by seq number check */
 711
 712         if (!NT_STATUS_IS_OK(domain->last_status))
 713                 return domain->last_status;
 714
 715         /* Put the query_user_list() in a retry loop.  There appears to be
 716          * some bug either with Windows 2000 or Samba's handling of large
 717          * rpc replies.  This manifests itself as sudden disconnection
 718          * at a random point in the enumeration of a large (60k) user list.
 719          * The retry loop simply tries the operation again. )-:  It's not
 720          * pretty but an acceptable workaround until we work out what the
 721          * real problem is. */
 722
 723         retry = 0;
 724         do {
 725
 726                 DEBUG(10,("query_user_list: [Cached] - doing backend query for list for domain %s\n",
 727                         domain->name ));
 728
 729                 status = domain->backend->query_user_list(domain, mem_ctx, num_entries, info);
 730                 if (!NT_STATUS_IS_OK(status))
 731                         DEBUG(3, ("query_user_list: returned 0x%08x, retrying\n", NT_STATUS_V(status)));
 732                         if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL)) {
 733                                 DEBUG(3, ("query_user_list: flushing connection cache\n"));
 734                                 winbindd_cm_flush();
 735                         }
 736
 737         } while (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) &&
 738                  (retry++ < 5));
 739
 740         /* and save it */
 741         refresh_sequence_number(domain, False);
 742         centry = centry_start(domain, status);
 743         if (!centry)
 744                 goto skip_save;
 745         centry_put_uint32(centry, *num_entries);
 746         for (i=0; i<(*num_entries); i++) {
 747                 centry_put_string(centry, (*info)[i].acct_name);
 748                 centry_put_string(centry, (*info)[i].full_name);
 749                 centry_put_sid(centry, (*info)[i].user_sid);
 750                 centry_put_sid(centry, (*info)[i].group_sid);
 751                 if (domain->backend->consistent) {
 752                         /* when the backend is consistent we can pre-prime some mappings */
 753                         wcache_save_name_to_sid(domain, NT_STATUS_OK,
 754                                                 domain->name,
 755                                                 (*info)[i].acct_name,
 756                                                 (*info)[i].user_sid,
 757                                                 SID_NAME_USER);
 758                         wcache_save_sid_to_name(domain, NT_STATUS_OK,
 759                                                 (*info)[i].user_sid,
 760                                                 domain->name,
 761                                                 (*info)[i].acct_name,
 762                                                 SID_NAME_USER);
 763                         wcache_save_user(domain, NT_STATUS_OK, &(*info)[i]);
 764                 }
 765         }
 766         centry_end(centry, "UL/%s", domain->name);
 767         centry_free(centry);
 768
 769 skip_save:
 770         return status;
 771 }
 772
 773 /* list all domain groups */
 774 static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
 775                                 TALLOC_CTX *mem_ctx,
 776                                 uint32 *num_entries,
 777                                 struct acct_info **info)
 778 {
 779         struct winbind_cache *cache = get_cache(domain);
 780         struct cache_entry *centry = NULL;
 781         NTSTATUS status;
 782         unsigned int i;
 783
 784         if (!cache->tdb)
 785                 goto do_query;
 786
 787         centry = wcache_fetch(cache, domain, "GL/%s/domain", domain->name);
 788         if (!centry)
 789                 goto do_query;
 790
 791         *num_entries = centry_uint32(centry);
 792
 793         if (*num_entries == 0)
 794                 goto do_cached;
 795
 796         (*info) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_entries);
 797         if (! (*info))
 798                 smb_panic("enum_dom_groups out of memory");
 799         for (i=0; i<(*num_entries); i++) {
 800                 fstrcpy((*info)[i].acct_name, centry_string(centry, mem_ctx));
 801                 fstrcpy((*info)[i].acct_desc, centry_string(centry, mem_ctx));
 802                 (*info)[i].rid = centry_uint32(centry);
 803         }
 804
 805 do_cached:
 806         status = centry->status;
 807
 808         DEBUG(10,("enum_dom_groups: [Cached] - cached list for domain %s status %s\n",
 809                 domain->name, get_friendly_nt_error_msg(status) ));
 810
 811         centry_free(centry);
 812         return status;
 813
 814 do_query:
 815         *num_entries = 0;
 816         *info = NULL;
 817
 818         /* Return status value returned by seq number check */
 819
 820         if (!NT_STATUS_IS_OK(domain->last_status))
 821                 return domain->last_status;
 822
 823         DEBUG(10,("enum_dom_groups: [Cached] - doing backend query for list for domain %s\n",
 824                 domain->name ));
 825
 826         status = domain->backend->enum_dom_groups(domain, mem_ctx, num_entries, info);
 827
 828         /* and save it */
 829         refresh_sequence_number(domain, False);
 830         centry = centry_start(domain, status);
 831         if (!centry)
 832                 goto skip_save;
 833         centry_put_uint32(centry, *num_entries);
 834         for (i=0; i<(*num_entries); i++) {
 835                 centry_put_string(centry, (*info)[i].acct_name);
 836                 centry_put_string(centry, (*info)[i].acct_desc);
 837                 centry_put_uint32(centry, (*info)[i].rid);
 838         }
 839         centry_end(centry, "GL/%s/domain", domain->name);
 840         centry_free(centry);
 841
 842 skip_save:
 843         return status;
 844 }
 845
 846 /* list all domain groups */
 847 static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
 848                                 TALLOC_CTX *mem_ctx,
 849                                 uint32 *num_entries,
 850                                 struct acct_info **info)
 851 {
 852         struct winbind_cache *cache = get_cache(domain);
 853         struct cache_entry *centry = NULL;
 854         NTSTATUS status;
 855         unsigned int i;
 856
 857         if (!cache->tdb)
 858                 goto do_query;
 859
 860         centry = wcache_fetch(cache, domain, "GL/%s/local", domain->name);
 861         if (!centry)
 862                 goto do_query;
 863
 864         *num_entries = centry_uint32(centry);
 865
 866         if (*num_entries == 0)
 867                 goto do_cached;
 868
 869         (*info) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_entries);
 870         if (! (*info))
 871                 smb_panic("enum_dom_groups out of memory");
 872         for (i=0; i<(*num_entries); i++) {
 873                 fstrcpy((*info)[i].acct_name, centry_string(centry, mem_ctx));
 874                 fstrcpy((*info)[i].acct_desc, centry_string(centry, mem_ctx));
 875                 (*info)[i].rid = centry_uint32(centry);
 876         }
 877
 878 do_cached:
 879
 880         /* If we are returning cached data and the domain controller
 881            is down then we don't know whether the data is up to date
 882            or not.  Return NT_STATUS_MORE_PROCESSING_REQUIRED to
 883            indicate this. */
 884
 885         if (wcache_server_down(domain)) {
 886                 DEBUG(10, ("enum_local_groups: returning cached user list and server was down\n"));
 887                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
 888         } else
 889                 status = centry->status;
 890
 891         DEBUG(10,("enum_local_groups: [Cached] - cached list for domain %s status %s\n",
 892                 domain->name, get_friendly_nt_error_msg(status) ));
 893
 894         centry_free(centry);
 895         return status;
 896
 897 do_query:
 898         *num_entries = 0;
 899         *info = NULL;
 900
 901         /* Return status value returned by seq number check */
 902
 903         if (!NT_STATUS_IS_OK(domain->last_status))
 904                 return domain->last_status;
 905
 906         DEBUG(10,("enum_local_groups: [Cached] - doing backend query for list for domain %s\n",
 907                 domain->name ));
 908
 909         status = domain->backend->enum_local_groups(domain, mem_ctx, num_entries, info);
 910
 911         /* and save it */
 912         refresh_sequence_number(domain, False);
 913         centry = centry_start(domain, status);
 914         if (!centry)
 915                 goto skip_save;
 916         centry_put_uint32(centry, *num_entries);
 917         for (i=0; i<(*num_entries); i++) {
 918                 centry_put_string(centry, (*info)[i].acct_name);
 919                 centry_put_string(centry, (*info)[i].acct_desc);
 920                 centry_put_uint32(centry, (*info)[i].rid);
 921         }
 922         centry_end(centry, "GL/%s/local", domain->name);
 923         centry_free(centry);
 924
 925 skip_save:
 926         return status;
 927 }
 928
 929 /* convert a single name to a sid in a domain */
 930 static NTSTATUS name_to_sid(struct winbindd_domain *domain,
 931                             TALLOC_CTX *mem_ctx,
 932                             const char *domain_name,
 933                             const char *name,
 934                             DOM_SID *sid,
 935                             enum SID_NAME_USE *type)
 936 {
 937         struct winbind_cache *cache = get_cache(domain);
 938         struct cache_entry *centry = NULL;
 939         NTSTATUS status;
 940         fstring uname;
 941         DOM_SID *sid2;
 942
 943         if (!cache->tdb)
 944                 goto do_query;
 945
 946         fstrcpy(uname, name);
 947         strupper_m(uname);
 948         centry = wcache_fetch(cache, domain, "NS/%s/%s", domain_name, uname);
 949         if (!centry)
 950                 goto do_query;
 951         *type = (enum SID_NAME_USE)centry_uint32(centry);
 952         sid2 = centry_sid(centry, mem_ctx);
 953         if (!sid2) {
 954                 ZERO_STRUCTP(sid);
 955         } else {
 956                 sid_copy(sid, sid2);
 957         }
 958
 959         status = centry->status;
 960
 961         DEBUG(10,("name_to_sid: [Cached] - cached name for domain %s status %s\n",
 962                 domain->name, get_friendly_nt_error_msg(status) ));
 963
 964         centry_free(centry);
 965         return status;
 966
 967 do_query:
 968         ZERO_STRUCTP(sid);
 969
 970         /* If the seq number check indicated that there is a problem
 971          * with this DC, then return that status... except for
 972          * access_denied.  This is special because the dc may be in
 973          * "restrict anonymous = 1" mode, in which case it will deny
 974          * most unauthenticated operations, but *will* allow the LSA
 975          * name-to-sid that we try as a fallback. */
 976
 977         if (!(NT_STATUS_IS_OK(domain->last_status)
 978               || NT_STATUS_EQUAL(domain->last_status, NT_STATUS_ACCESS_DENIED)))
 979                 return domain->last_status;
 980
 981         DEBUG(10,("name_to_sid: [Cached] - doing backend query for name for domain %s\n",
 982                 domain->name ));
 983
 984         status = domain->backend->name_to_sid(domain, mem_ctx, domain_name, name, sid, type);
 985
 986         /* and save it */
 987         wcache_save_name_to_sid(domain, status, domain_name, name, sid, *type);
 988
 989         /* We can't save the sid to name mapping as we don't know the
 990            correct case of the name without looking it up */
 991
 992         return status;
 993 }
 994
 995 /* convert a sid to a user or group name. The sid is guaranteed to be in the domain
 996    given */
 997 static NTSTATUS sid_to_name(struct winbindd_domain *domain,
 998                             TALLOC_CTX *mem_ctx,
 999                             const DOM_SID *sid,
1000                             char **domain_name,
1001                             char **name,
1002                             enum SID_NAME_USE *type)
1003 {
1004         struct winbind_cache *cache = get_cache(domain);
1005         struct cache_entry *centry = NULL;
1006         NTSTATUS status;
1007         fstring sid_string;
1008
1009         if (!cache->tdb)
1010                 goto do_query;
1011
1012         centry = wcache_fetch(cache, domain, "SN/%s", sid_to_string(sid_string, sid));
1013         if (!centry)
1014                 goto do_query;
1015         if (NT_STATUS_IS_OK(centry->status)) {
1016                 *type = (enum SID_NAME_USE)centry_uint32(centry);
1017                 *domain_name = centry_string(centry, mem_ctx);
1018                 *name = centry_string(centry, mem_ctx);
1019         }
1020         status = centry->status;
1021
1022         DEBUG(10,("sid_to_name: [Cached] - cached name for domain %s status %s\n",
1023                 domain->name, get_friendly_nt_error_msg(status) ));
1024
1025         centry_free(centry);
1026         return status;
1027
1028 do_query:
1029         *name = NULL;
1030         *domain_name = NULL;
1031
1032         /* If the seq number check indicated that there is a problem
1033          * with this DC, then return that status... except for
1034          * access_denied.  This is special because the dc may be in
1035          * "restrict anonymous = 1" mode, in which case it will deny
1036          * most unauthenticated operations, but *will* allow the LSA
1037          * sid-to-name that we try as a fallback. */
1038
1039         if (!(NT_STATUS_IS_OK(domain->last_status)
1040               || NT_STATUS_EQUAL(domain->last_status, NT_STATUS_ACCESS_DENIED)))
1041                 return domain->last_status;
1042
1043         DEBUG(10,("sid_to_name: [Cached] - doing backend query for name for domain %s\n",
1044                 domain->name ));
1045
1046         status = domain->backend->sid_to_name(domain, mem_ctx, sid, domain_name, name, type);
1047
1048         /* and save it */
1049         refresh_sequence_number(domain, False);
1050         wcache_save_sid_to_name(domain, status, sid, *domain_name, *name, *type);
1051
1052         /* We can't save the name to sid mapping here, as with sid history a
1053          * later name2sid would give the wrong sid. */
1054
1055         return status;
1056 }
1057
1058
1059 /* Lookup user information from a rid */
1060 static NTSTATUS query_user(struct winbindd_domain *domain,
1061                            TALLOC_CTX *mem_ctx,
1062                            const DOM_SID *user_sid,
1063                            WINBIND_USERINFO *info)
1064 {
1065         struct winbind_cache *cache = get_cache(domain);
1066         struct cache_entry *centry = NULL;
1067         NTSTATUS status;
1068
1069         if (!cache->tdb)
1070                 goto do_query;
1071
1072         centry = wcache_fetch(cache, domain, "U/%s", sid_string_static(user_sid));
1073
1074         /* If we have an access denied cache entry and a cached info3 in the
1075            samlogon cache then do a query.  This will force the rpc back end
1076            to return the info3 data. */
1077
1078         if (NT_STATUS_V(domain->last_status) == NT_STATUS_V(NT_STATUS_ACCESS_DENIED) &&
1079             netsamlogon_cache_have(user_sid)) {
1080                 DEBUG(10, ("query_user: cached access denied and have cached info3\n"));
1081                 domain->last_status = NT_STATUS_OK;
1082                 centry_free(centry);
1083                 goto do_query;
1084         }
1085
1086         if (!centry)
1087                 goto do_query;
1088
1089         info->acct_name = centry_string(centry, mem_ctx);
1090         info->full_name = centry_string(centry, mem_ctx);
1091         info->user_sid = centry_sid(centry, mem_ctx);
1092         info->group_sid = centry_sid(centry, mem_ctx);
1093         status = centry->status;
1094
1095         DEBUG(10,("query_user: [Cached] - cached info for domain %s status %s\n",
1096                 domain->name, get_friendly_nt_error_msg(status) ));
1097
1098         centry_free(centry);
1099         return status;
1100
1101 do_query:
1102         ZERO_STRUCTP(info);
1103
1104         /* Return status value returned by seq number check */
1105
1106         if (!NT_STATUS_IS_OK(domain->last_status))
1107                 return domain->last_status;
1108
1109         DEBUG(10,("sid_to_name: [Cached] - doing backend query for info for domain %s\n",
1110                 domain->name ));
1111
1112         status = domain->backend->query_user(domain, mem_ctx, user_sid, info);
1113
1114         /* and save it */
1115         refresh_sequence_number(domain, False);
1116         wcache_save_user(domain, status, info);
1117
1118         return status;
1119 }
1120
1121
1122 /* Lookup groups a user is a member of. */
1123 static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
1124                                   TALLOC_CTX *mem_ctx,
1125                                   const DOM_SID *user_sid,
1126                                   uint32 *num_groups, DOM_SID ***user_gids)
1127 {
1128         struct winbind_cache *cache = get_cache(domain);
1129         struct cache_entry *centry = NULL;
1130         NTSTATUS status;
1131         unsigned int i;
1132         fstring sid_string;
1133
1134         if (!cache->tdb)
1135                 goto do_query;
1136
1137         centry = wcache_fetch(cache, domain, "UG/%s", sid_to_string(sid_string, user_sid));
1138
1139         /* If we have an access denied cache entry and a cached info3 in the
1140            samlogon cache then do a query.  This will force the rpc back end
1141            to return the info3 data. */
1142
1143         if (NT_STATUS_V(domain->last_status) == NT_STATUS_V(NT_STATUS_ACCESS_DENIED) &&
1144             netsamlogon_cache_have(user_sid)) {
1145                 DEBUG(10, ("query_user: cached access denied and have cached info3\n"));
1146                 domain->last_status = NT_STATUS_OK;
1147                 centry_free(centry);
1148                 goto do_query;
1149         }
1150
1151         if (!centry)
1152                 goto do_query;
1153
1154         *num_groups = centry_uint32(centry);
1155
1156         if (*num_groups == 0)
1157                 goto do_cached;
1158
1159         (*user_gids) = TALLOC_ARRAY(mem_ctx, DOM_SID *, *num_groups);
1160         if (! (*user_gids))
1161                 smb_panic("lookup_usergroups out of memory");
1162         for (i=0; i<(*num_groups); i++) {
1163                 (*user_gids)[i] = centry_sid(centry, mem_ctx);
1164         }
1165
1166 do_cached:
1167         status = centry->status;
1168
1169         DEBUG(10,("lookup_usergroups: [Cached] - cached info for domain %s status %s\n",
1170                 domain->name, get_friendly_nt_error_msg(status) ));
1171
1172         centry_free(centry);
1173         return status;
1174
1175 do_query:
1176         (*num_groups) = 0;
1177         (*user_gids) = NULL;
1178
1179         /* Return status value returned by seq number check */
1180
1181         if (!NT_STATUS_IS_OK(domain->last_status))
1182                 return domain->last_status;
1183
1184         DEBUG(10,("lookup_usergroups: [Cached] - doing backend query for info for domain %s\n",
1185                 domain->name ));
1186
1187         status = domain->backend->lookup_usergroups(domain, mem_ctx, user_sid, num_groups, user_gids);
1188
1189         /* and save it */
1190         refresh_sequence_number(domain, False);
1191         centry = centry_start(domain, status);
1192         if (!centry)
1193                 goto skip_save;
1194         centry_put_uint32(centry, *num_groups);
1195         for (i=0; i<(*num_groups); i++) {
1196                 centry_put_sid(centry, (*user_gids)[i]);
1197         }
1198         centry_end(centry, "UG/%s", sid_to_string(sid_string, user_sid));
1199         centry_free(centry);
1200
1201 skip_save:
1202         return status;
1203 }
1204
1205
1206 static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
1207                                 TALLOC_CTX *mem_ctx,
1208                                 const DOM_SID *group_sid, uint32 *num_names,
1209                                 DOM_SID ***sid_mem, char ***names,
1210                                 uint32 **name_types)
1211 {
1212         struct winbind_cache *cache = get_cache(domain);
1213         struct cache_entry *centry = NULL;
1214         NTSTATUS status;
1215         unsigned int i;
1216         fstring sid_string;
1217
1218         if (!cache->tdb)
1219                 goto do_query;
1220
1221         centry = wcache_fetch(cache, domain, "GM/%s", sid_to_string(sid_string, group_sid));
1222         if (!centry)
1223                 goto do_query;
1224
1225         *num_names = centry_uint32(centry);
1226
1227         if (*num_names == 0)
1228                 goto do_cached;
1229
1230         (*sid_mem) = TALLOC_ARRAY(mem_ctx, DOM_SID *, *num_names);
1231         (*names) = TALLOC_ARRAY(mem_ctx, char *, *num_names);
1232         (*name_types) = TALLOC_ARRAY(mem_ctx, uint32, *num_names);
1233
1234         if (! (*sid_mem) || ! (*names) || ! (*name_types)) {
1235                 smb_panic("lookup_groupmem out of memory");
1236         }
1237
1238         for (i=0; i<(*num_names); i++) {
1239                 (*sid_mem)[i] = centry_sid(centry, mem_ctx);
1240                 (*names)[i] = centry_string(centry, mem_ctx);
1241                 (*name_types)[i] = centry_uint32(centry);
1242         }
1243
1244 do_cached:
1245         status = centry->status;
1246
1247         DEBUG(10,("lookup_groupmem: [Cached] - cached info for domain %s status %s\n",
1248                 domain->name, get_friendly_nt_error_msg(status) ));
1249
1250         centry_free(centry);
1251         return status;
1252
1253 do_query:
1254         (*num_names) = 0;
1255         (*sid_mem) = NULL;
1256         (*names) = NULL;
1257         (*name_types) = NULL;
1258
1259         /* Return status value returned by seq number check */
1260
1261         if (!NT_STATUS_IS_OK(domain->last_status))
1262                 return domain->last_status;
1263
1264         DEBUG(10,("lookup_groupmem: [Cached] - doing backend query for info for domain %s\n",
1265                 domain->name ));
1266
1267         status = domain->backend->lookup_groupmem(domain, mem_ctx, group_sid, num_names,
1268                                                   sid_mem, names, name_types);
1269
1270         /* and save it */
1271         refresh_sequence_number(domain, False);
1272         centry = centry_start(domain, status);
1273         if (!centry)
1274                 goto skip_save;
1275         centry_put_uint32(centry, *num_names);
1276         for (i=0; i<(*num_names); i++) {
1277                 centry_put_sid(centry, (*sid_mem)[i]);
1278                 centry_put_string(centry, (*names)[i]);
1279                 centry_put_uint32(centry, (*name_types)[i]);
1280         }
1281         centry_end(centry, "GM/%s", sid_to_string(sid_string, group_sid));
1282         centry_free(centry);
1283
1284 skip_save:
1285         return status;
1286 }
1287
1288 /* find the sequence number for a domain */
1289 static NTSTATUS sequence_number(struct winbindd_domain *domain, uint32 *seq)
1290 {
1291         refresh_sequence_number(domain, False);
1292
1293         *seq = domain->sequence_number;
1294
1295         return NT_STATUS_OK;
1296 }
1297
1298 /* enumerate trusted domains */
1299 static NTSTATUS trusted_domains(struct winbindd_domain *domain,
1300                                 TALLOC_CTX *mem_ctx,
1301                                 uint32 *num_domains,
1302                                 char ***names,
1303                                 char ***alt_names,
1304                                 DOM_SID **dom_sids)
1305 {
1306         get_cache(domain);
1307
1308         DEBUG(10,("trusted_domains: [Cached] - doing backend query for info for domain %s\n",
1309                 domain->name ));
1310
1311         /* we don't cache this call */
1312         return domain->backend->trusted_domains(domain, mem_ctx, num_domains,
1313                                                names, alt_names, dom_sids);
1314 }
1315
1316 /* find the domain sid */
1317 static NTSTATUS domain_sid(struct winbindd_domain *domain, DOM_SID *sid)
1318 {
1319         get_cache(domain);
1320
1321         DEBUG(10,("domain_sid: [Cached] - doing backend query for info for domain %s\n",
1322                 domain->name ));
1323
1324         /* we don't cache this call */
1325         return domain->backend->domain_sid(domain, sid);
1326 }
1327
1328 /* find the alternate names for the domain, if any */
1329 static NTSTATUS alternate_name(struct winbindd_domain *domain)
1330 {
1331         get_cache(domain);
1332
1333         DEBUG(10,("alternate_name: [Cached] - doing backend query for info for domain %s\n",
1334                 domain->name ));
1335
1336         /* we don't cache this call */
1337         return domain->backend->alternate_name(domain);
1338 }
1339
1340 /* Invalidate cached user and group lists coherently */
1341
1342 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1343                        void *state)
1344 {
1345         if (strncmp(kbuf.dptr, "UL/", 3) == 0 ||
1346             strncmp(kbuf.dptr, "GL/", 3) == 0)
1347                 tdb_delete(the_tdb, kbuf);
1348
1349         return 0;
1350 }
1351
1352 /* Invalidate the getpwnam and getgroups entries for a winbindd domain */
1353
1354 void wcache_invalidate_samlogon(struct winbindd_domain *domain,
1355                                 NET_USER_INFO_3 *info3)
1356 {
1357         struct winbind_cache *cache;
1358
1359         if (!domain)
1360                 return;
1361
1362         cache = get_cache(domain);
1363         netsamlogon_clear_cached_user(cache->tdb, info3);
1364 }
1365
1366 void wcache_invalidate_cache(void)
1367 {
1368         struct winbindd_domain *domain;
1369
1370         for (domain = domain_list(); domain; domain = domain->next) {
1371                 struct winbind_cache *cache = get_cache(domain);
1372
1373                 DEBUG(10, ("wcache_invalidate_cache: invalidating cache "
1374                            "entries for %s\n", domain->name));
1375                 if (cache)
1376                         tdb_traverse(cache->tdb, traverse_fn, NULL);
1377         }
1378 }
1379
1380 /* the ADS backend methods are exposed via this structure */
1381 struct winbindd_methods cache_methods = {
1382         True,
1383         query_user_list,
1384         enum_dom_groups,
1385         enum_local_groups,
1386         name_to_sid,
1387         sid_to_name,
1388         query_user,
1389         lookup_usergroups,
1390         lookup_groupmem,
1391         sequence_number,
1392         trusted_domains,
1393         domain_sid,
1394         alternate_name
1395 };