source3/nsswitch/winbindd_cache.c

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