import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / 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(sizeof(*ret));
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(mem_ctx, sizeof(*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         /* have we expired? */
280         
281         time_diff = now - domain->last_seq_check;
282         if ( time_diff > lp_winbind_cache_time() ) {
283                 DEBUG(10,("fetch_cache_seqnum: timeout [%s][%u @ %u]\n",
284                         domain->name, domain->sequence_number,
285                         (uint32)domain->last_seq_check));
286                 return NT_STATUS_UNSUCCESSFUL;
287         }
288
289         DEBUG(10,("fetch_cache_seqnum: success [%s][%u @ %u]\n", 
290                 domain->name, domain->sequence_number, 
291                 (uint32)domain->last_seq_check));
292
293         return NT_STATUS_OK;
294 }
295
296 static NTSTATUS store_cache_seqnum( struct winbindd_domain *domain )
297 {
298         TDB_DATA data, key;
299         fstring key_str;
300         char buf[8];
301         
302         if (!wcache->tdb) {
303                 DEBUG(10,("store_cache_seqnum: tdb == NULL\n"));
304                 return NT_STATUS_UNSUCCESSFUL;
305         }
306                 
307         fstr_sprintf( key_str, "SEQNUM/%s", domain->name );
308         key.dptr = key_str;
309         key.dsize = strlen(key_str)+1;
310         
311         SIVAL(buf, 0, domain->sequence_number);
312         SIVAL(buf, 4, domain->last_seq_check);
313         data.dptr = buf;
314         data.dsize = 8;
315         
316         if ( tdb_store( wcache->tdb, key, data, TDB_REPLACE) == -1 ) {
317                 DEBUG(10,("store_cache_seqnum: tdb_store fail key [%s]\n", key_str ));
318                 return NT_STATUS_UNSUCCESSFUL;
319         }
320
321         DEBUG(10,("store_cache_seqnum: success [%s][%u @ %u]\n", 
322                 domain->name, domain->sequence_number, 
323                 (uint32)domain->last_seq_check));
324         
325         return NT_STATUS_OK;
326 }
327
328 /*
329   refresh the domain sequence number. If force is True
330   then always refresh it, no matter how recently we fetched it
331 */
332
333 static void refresh_sequence_number(struct winbindd_domain *domain, BOOL force)
334 {
335         NTSTATUS status;
336         unsigned time_diff;
337         time_t t = time(NULL);
338         unsigned cache_time = lp_winbind_cache_time();
339
340         get_cache( domain );
341
342 #if 0   /* JERRY -- disable as the default cache time is now 5 minutes */
343         /* trying to reconnect is expensive, don't do it too often */
344         if (domain->sequence_number == DOM_SEQUENCE_NONE) {
345                 cache_time *= 8;
346         }
347 #endif
348
349         time_diff = t - domain->last_seq_check;
350
351         /* see if we have to refetch the domain sequence number */
352         if (!force && (time_diff < cache_time)) {
353                 DEBUG(10, ("refresh_sequence_number: %s time ok\n", domain->name));
354                 goto done;
355         }
356         
357         /* try to get the sequence number from the tdb cache first */
358         /* this will update the timestamp as well */
359         
360         status = fetch_cache_seqnum( domain, t );
361         if ( NT_STATUS_IS_OK(status) )
362                 goto done;      
363
364         status = domain->backend->sequence_number(domain, &domain->sequence_number);
365
366         if (!NT_STATUS_IS_OK(status)) {
367                 domain->sequence_number = DOM_SEQUENCE_NONE;
368         }
369         
370         domain->last_status = status;
371         domain->last_seq_check = time(NULL);
372         
373         /* save the new sequence number ni the cache */
374         store_cache_seqnum( domain );
375
376 done:
377         DEBUG(10, ("refresh_sequence_number: %s seq number is now %d\n", 
378                    domain->name, domain->sequence_number));
379
380         return;
381 }
382
383 /*
384   decide if a cache entry has expired
385 */
386 static BOOL centry_expired(struct winbindd_domain *domain, const char *keystr, struct cache_entry *centry)
387 {
388         /* if the server is OK and our cache entry came from when it was down then
389            the entry is invalid */
390         if (domain->sequence_number != DOM_SEQUENCE_NONE && 
391             centry->sequence_number == DOM_SEQUENCE_NONE) {
392                 DEBUG(10,("centry_expired: Key %s for domain %s invalid sequence.\n",
393                         keystr, domain->name ));
394                 return True;
395         }
396
397         /* if the server is down or the cache entry is not older than the
398            current sequence number then it is OK */
399         if (wcache_server_down(domain) || 
400             centry->sequence_number == domain->sequence_number) {
401                 DEBUG(10,("centry_expired: Key %s for domain %s is good.\n",
402                         keystr, domain->name ));
403                 return False;
404         }
405
406         DEBUG(10,("centry_expired: Key %s for domain %s expired\n",
407                 keystr, domain->name ));
408
409         /* it's expired */
410         return True;
411 }
412
413 /*
414   fetch an entry from the cache, with a varargs key. auto-fetch the sequence
415   number and return status
416 */
417 static struct cache_entry *wcache_fetch(struct winbind_cache *cache, 
418                                         struct winbindd_domain *domain,
419                                         const char *format, ...) PRINTF_ATTRIBUTE(3,4);
420 static struct cache_entry *wcache_fetch(struct winbind_cache *cache, 
421                                         struct winbindd_domain *domain,
422                                         const char *format, ...)
423 {
424         va_list ap;
425         char *kstr;
426         TDB_DATA data;
427         struct cache_entry *centry;
428         TDB_DATA key;
429
430         refresh_sequence_number(domain, False);
431
432         va_start(ap, format);
433         smb_xvasprintf(&kstr, format, ap);
434         va_end(ap);
435         
436         key.dptr = kstr;
437         key.dsize = strlen(kstr);
438         data = tdb_fetch(wcache->tdb, key);
439         if (!data.dptr) {
440                 /* a cache miss */
441                 free(kstr);
442                 return NULL;
443         }
444
445         centry = smb_xmalloc(sizeof(*centry));
446         centry->data = (unsigned char *)data.dptr;
447         centry->len = data.dsize;
448         centry->ofs = 0;
449
450         if (centry->len < 8) {
451                 /* huh? corrupt cache? */
452                 DEBUG(10,("wcache_fetch: Corrupt cache for key %s domain %s (len < 8) ?\n",
453                         kstr, domain->name ));
454                 centry_free(centry);
455                 free(kstr);
456                 return NULL;
457         }
458         
459         centry->status = NT_STATUS(centry_uint32(centry));
460         centry->sequence_number = centry_uint32(centry);
461
462         if (centry_expired(domain, kstr, centry)) {
463                 extern BOOL opt_dual_daemon;
464
465                 DEBUG(10,("wcache_fetch: entry %s expired for domain %s\n",
466                          kstr, domain->name ));
467
468                 if (opt_dual_daemon) {
469                         extern BOOL background_process;
470                         background_process = True;
471                         DEBUG(10,("wcache_fetch: background processing expired entry %s for domain %s\n",
472                                  kstr, domain->name ));
473                 } else {
474                         centry_free(centry);
475                         free(kstr);
476                         return NULL;
477                 }
478         }
479
480         DEBUG(10,("wcache_fetch: returning entry %s for domain %s\n",
481                  kstr, domain->name ));
482
483         free(kstr);
484         return centry;
485 }
486
487 /*
488   make sure we have at least len bytes available in a centry 
489 */
490 static void centry_expand(struct cache_entry *centry, uint32 len)
491 {
492         uint8 *p;
493         if (centry->len - centry->ofs >= len)
494                 return;
495         centry->len *= 2;
496         p = realloc(centry->data, centry->len);
497         if (!p) {
498                 DEBUG(0,("out of memory: needed %d bytes in centry_expand\n", centry->len));
499                 smb_panic("out of memory in centry_expand");
500         }
501         centry->data = p;
502 }
503
504 /*
505   push a uint32 into a centry 
506 */
507 static void centry_put_uint32(struct cache_entry *centry, uint32 v)
508 {
509         centry_expand(centry, 4);
510         SIVAL(centry->data, centry->ofs, v);
511         centry->ofs += 4;
512 }
513
514 /*
515   push a uint8 into a centry 
516 */
517 static void centry_put_uint8(struct cache_entry *centry, uint8 v)
518 {
519         centry_expand(centry, 1);
520         SCVAL(centry->data, centry->ofs, v);
521         centry->ofs += 1;
522 }
523
524 /* 
525    push a string into a centry 
526  */
527 static void centry_put_string(struct cache_entry *centry, const char *s)
528 {
529         int len;
530
531         if (!s) {
532                 /* null strings are marked as len 0xFFFF */
533                 centry_put_uint8(centry, 0xFF);
534                 return;
535         }
536
537         len = strlen(s);
538         /* can't handle more than 254 char strings. Truncating is probably best */
539         if (len > 254)
540                 len = 254;
541         centry_put_uint8(centry, len);
542         centry_expand(centry, len);
543         memcpy(centry->data + centry->ofs, s, len);
544         centry->ofs += len;
545 }
546
547 static void centry_put_sid(struct cache_entry *centry, const DOM_SID *sid) 
548 {
549         fstring sid_string;
550         centry_put_string(centry, sid_to_string(sid_string, sid));
551 }
552
553 /*
554   start a centry for output. When finished, call centry_end()
555 */
556 struct cache_entry *centry_start(struct winbindd_domain *domain, NTSTATUS status)
557 {
558         struct cache_entry *centry;
559
560         if (!wcache->tdb)
561                 return NULL;
562
563         centry = smb_xmalloc(sizeof(*centry));
564
565         centry->len = 8192; /* reasonable default */
566         centry->data = smb_xmalloc(centry->len);
567         centry->ofs = 0;
568         centry->sequence_number = domain->sequence_number;
569         centry_put_uint32(centry, NT_STATUS_V(status));
570         centry_put_uint32(centry, centry->sequence_number);
571         return centry;
572 }
573
574 /*
575   finish a centry and write it to the tdb
576 */
577 static void centry_end(struct cache_entry *centry, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
578 static void centry_end(struct cache_entry *centry, const char *format, ...)
579 {
580         va_list ap;
581         char *kstr;
582         TDB_DATA key, data;
583
584         va_start(ap, format);
585         smb_xvasprintf(&kstr, format, ap);
586         va_end(ap);
587
588         key.dptr = kstr;
589         key.dsize = strlen(kstr);
590         data.dptr = (char *)centry->data;
591         data.dsize = centry->ofs;
592
593         tdb_store(wcache->tdb, key, data, TDB_REPLACE);
594         free(kstr);
595 }
596
597 static void wcache_save_name_to_sid(struct winbindd_domain *domain, 
598                                     NTSTATUS status, 
599                                     const char *name, const DOM_SID *sid, 
600                                     enum SID_NAME_USE type)
601 {
602         struct cache_entry *centry;
603         fstring uname;
604         fstring sid_string;
605
606         centry = centry_start(domain, status);
607         if (!centry)
608                 return;
609         centry_put_sid(centry, sid);
610         fstrcpy(uname, name);
611         strupper_m(uname);
612         centry_end(centry, "NS/%s", sid_to_string(sid_string, sid));
613         DEBUG(10,("wcache_save_name_to_sid: %s -> %s\n", uname, sid_string));
614         centry_free(centry);
615 }
616
617 static void wcache_save_sid_to_name(struct winbindd_domain *domain, NTSTATUS status, 
618                                     const DOM_SID *sid, const char *name, enum SID_NAME_USE type)
619 {
620         struct cache_entry *centry;
621         fstring sid_string;
622
623         centry = centry_start(domain, status);
624         if (!centry)
625                 return;
626         if (NT_STATUS_IS_OK(status)) {
627                 centry_put_uint32(centry, type);
628                 centry_put_string(centry, name);
629         }
630         centry_end(centry, "SN/%s", sid_to_string(sid_string, sid));
631         DEBUG(10,("wcache_save_sid_to_name: %s -> %s\n", sid_string, name));
632         centry_free(centry);
633 }
634
635
636 static void wcache_save_user(struct winbindd_domain *domain, NTSTATUS status, WINBIND_USERINFO *info)
637 {
638         struct cache_entry *centry;
639         fstring sid_string;
640
641         centry = centry_start(domain, status);
642         if (!centry)
643                 return;
644         centry_put_string(centry, info->acct_name);
645         centry_put_string(centry, info->full_name);
646         centry_put_sid(centry, info->user_sid);
647         centry_put_sid(centry, info->group_sid);
648         centry_end(centry, "U/%s", sid_to_string(sid_string, info->user_sid));
649         DEBUG(10,("wcache_save_user: %s (acct_name %s)\n", sid_string, info->acct_name));
650         centry_free(centry);
651 }
652
653
654 /* Query display info. This is the basic user list fn */
655 static NTSTATUS query_user_list(struct winbindd_domain *domain,
656                                 TALLOC_CTX *mem_ctx,
657                                 uint32 *num_entries, 
658                                 WINBIND_USERINFO **info)
659 {
660         struct winbind_cache *cache = get_cache(domain);
661         struct cache_entry *centry = NULL;
662         NTSTATUS status;
663         unsigned int i, retry;
664
665         if (!cache->tdb)
666                 goto do_query;
667
668         centry = wcache_fetch(cache, domain, "UL/%s", domain->name);
669         if (!centry)
670                 goto do_query;
671
672         *num_entries = centry_uint32(centry);
673         
674         if (*num_entries == 0)
675                 goto do_cached;
676
677         (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
678         if (! (*info))
679                 smb_panic("query_user_list out of memory");
680         for (i=0; i<(*num_entries); i++) {
681                 (*info)[i].acct_name = centry_string(centry, mem_ctx);
682                 (*info)[i].full_name = centry_string(centry, mem_ctx);
683                 (*info)[i].user_sid = centry_sid(centry, mem_ctx);
684                 (*info)[i].group_sid = centry_sid(centry, mem_ctx);
685         }
686
687 do_cached:      
688         status = centry->status;
689
690         DEBUG(10,("query_user_list: [Cached] - cached list for domain %s status %s\n",
691                 domain->name, get_friendly_nt_error_msg(status) ));
692
693         centry_free(centry);
694         return status;
695
696 do_query:
697         *num_entries = 0;
698         *info = NULL;
699
700         /* Return status value returned by seq number check */
701
702         if (!NT_STATUS_IS_OK(domain->last_status))
703                 return domain->last_status;
704
705         /* Put the query_user_list() in a retry loop.  There appears to be
706          * some bug either with Windows 2000 or Samba's handling of large
707          * rpc replies.  This manifests itself as sudden disconnection
708          * at a random point in the enumeration of a large (60k) user list.
709          * The retry loop simply tries the operation again. )-:  It's not
710          * pretty but an acceptable workaround until we work out what the
711          * real problem is. */
712
713         retry = 0;
714         do {
715
716                 DEBUG(10,("query_user_list: [Cached] - doing backend query for list for domain %s\n",
717                         domain->name ));
718
719                 status = domain->backend->query_user_list(domain, mem_ctx, num_entries, info);
720                 if (!NT_STATUS_IS_OK(status))
721                         DEBUG(3, ("query_user_list: returned 0x%08x, retrying\n", NT_STATUS_V(status)));
722                         if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL)) {
723                                 DEBUG(3, ("query_user_list: flushing connection cache\n"));
724                                 winbindd_cm_flush();
725                         }
726
727         } while (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) && 
728                  (retry++ < 5));
729
730         /* and save it */
731         refresh_sequence_number(domain, False);
732         centry = centry_start(domain, status);
733         if (!centry)
734                 goto skip_save;
735         centry_put_uint32(centry, *num_entries);
736         for (i=0; i<(*num_entries); i++) {
737                 centry_put_string(centry, (*info)[i].acct_name);
738                 centry_put_string(centry, (*info)[i].full_name);
739                 centry_put_sid(centry, (*info)[i].user_sid);
740                 centry_put_sid(centry, (*info)[i].group_sid);
741                 if (domain->backend->consistent) {
742                         /* when the backend is consistent we can pre-prime some mappings */
743                         wcache_save_name_to_sid(domain, NT_STATUS_OK, 
744                                                 (*info)[i].acct_name, 
745                                                 (*info)[i].user_sid,
746                                                 SID_NAME_USER);
747                         wcache_save_sid_to_name(domain, NT_STATUS_OK, 
748                                                 (*info)[i].user_sid,
749                                                 (*info)[i].acct_name, 
750                                                 SID_NAME_USER);
751                         wcache_save_user(domain, NT_STATUS_OK, &(*info)[i]);
752                 }
753         }       
754         centry_end(centry, "UL/%s", domain->name);
755         centry_free(centry);
756
757 skip_save:
758         return status;
759 }
760
761 /* list all domain groups */
762 static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
763                                 TALLOC_CTX *mem_ctx,
764                                 uint32 *num_entries, 
765                                 struct acct_info **info)
766 {
767         struct winbind_cache *cache = get_cache(domain);
768         struct cache_entry *centry = NULL;
769         NTSTATUS status;
770         unsigned int i;
771
772         if (!cache->tdb)
773                 goto do_query;
774
775         centry = wcache_fetch(cache, domain, "GL/%s/domain", domain->name);
776         if (!centry)
777                 goto do_query;
778
779         *num_entries = centry_uint32(centry);
780         
781         if (*num_entries == 0)
782                 goto do_cached;
783
784         (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
785         if (! (*info))
786                 smb_panic("enum_dom_groups out of memory");
787         for (i=0; i<(*num_entries); i++) {
788                 fstrcpy((*info)[i].acct_name, centry_string(centry, mem_ctx));
789                 fstrcpy((*info)[i].acct_desc, centry_string(centry, mem_ctx));
790                 (*info)[i].rid = centry_uint32(centry);
791         }
792
793 do_cached:      
794         status = centry->status;
795
796         DEBUG(10,("enum_dom_groups: [Cached] - cached list for domain %s status %s\n",
797                 domain->name, get_friendly_nt_error_msg(status) ));
798
799         centry_free(centry);
800         return status;
801
802 do_query:
803         *num_entries = 0;
804         *info = NULL;
805
806         /* Return status value returned by seq number check */
807
808         if (!NT_STATUS_IS_OK(domain->last_status))
809                 return domain->last_status;
810
811         DEBUG(10,("enum_dom_groups: [Cached] - doing backend query for list for domain %s\n",
812                 domain->name ));
813
814         status = domain->backend->enum_dom_groups(domain, mem_ctx, num_entries, info);
815
816         /* and save it */
817         refresh_sequence_number(domain, False);
818         centry = centry_start(domain, status);
819         if (!centry)
820                 goto skip_save;
821         centry_put_uint32(centry, *num_entries);
822         for (i=0; i<(*num_entries); i++) {
823                 centry_put_string(centry, (*info)[i].acct_name);
824                 centry_put_string(centry, (*info)[i].acct_desc);
825                 centry_put_uint32(centry, (*info)[i].rid);
826         }       
827         centry_end(centry, "GL/%s/domain", domain->name);
828         centry_free(centry);
829
830 skip_save:
831         return status;
832 }
833
834 /* list all domain groups */
835 static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
836                                 TALLOC_CTX *mem_ctx,
837                                 uint32 *num_entries, 
838                                 struct acct_info **info)
839 {
840         struct winbind_cache *cache = get_cache(domain);
841         struct cache_entry *centry = NULL;
842         NTSTATUS status;
843         unsigned int i;
844
845         if (!cache->tdb)
846                 goto do_query;
847
848         centry = wcache_fetch(cache, domain, "GL/%s/local", domain->name);
849         if (!centry)
850                 goto do_query;
851
852         *num_entries = centry_uint32(centry);
853         
854         if (*num_entries == 0)
855                 goto do_cached;
856
857         (*info) = talloc(mem_ctx, sizeof(**info) * (*num_entries));
858         if (! (*info))
859                 smb_panic("enum_dom_groups out of memory");
860         for (i=0; i<(*num_entries); i++) {
861                 fstrcpy((*info)[i].acct_name, centry_string(centry, mem_ctx));
862                 fstrcpy((*info)[i].acct_desc, centry_string(centry, mem_ctx));
863                 (*info)[i].rid = centry_uint32(centry);
864         }
865
866 do_cached:      
867
868         /* If we are returning cached data and the domain controller
869            is down then we don't know whether the data is up to date
870            or not.  Return NT_STATUS_MORE_PROCESSING_REQUIRED to
871            indicate this. */
872
873         if (wcache_server_down(domain)) {
874                 DEBUG(10, ("enum_local_groups: returning cached user list and server was down\n"));
875                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
876         } else
877                 status = centry->status;
878
879         DEBUG(10,("enum_local_groups: [Cached] - cached list for domain %s status %s\n",
880                 domain->name, get_friendly_nt_error_msg(status) ));
881
882         centry_free(centry);
883         return status;
884
885 do_query:
886         *num_entries = 0;
887         *info = NULL;
888
889         /* Return status value returned by seq number check */
890
891         if (!NT_STATUS_IS_OK(domain->last_status))
892                 return domain->last_status;
893
894         DEBUG(10,("enum_local_groups: [Cached] - doing backend query for list for domain %s\n",
895                 domain->name ));
896
897         status = domain->backend->enum_local_groups(domain, mem_ctx, num_entries, info);
898
899         /* and save it */
900         refresh_sequence_number(domain, False);
901         centry = centry_start(domain, status);
902         if (!centry)
903                 goto skip_save;
904         centry_put_uint32(centry, *num_entries);
905         for (i=0; i<(*num_entries); i++) {
906                 centry_put_string(centry, (*info)[i].acct_name);
907                 centry_put_string(centry, (*info)[i].acct_desc);
908                 centry_put_uint32(centry, (*info)[i].rid);
909         }
910         centry_end(centry, "GL/%s/local", domain->name);
911         centry_free(centry);
912
913 skip_save:
914         return status;
915 }
916
917 /* convert a single name to a sid in a domain */
918 static NTSTATUS name_to_sid(struct winbindd_domain *domain,
919                             TALLOC_CTX *mem_ctx,
920                             const char *name,
921                             DOM_SID *sid,
922                             enum SID_NAME_USE *type)
923 {
924         struct winbind_cache *cache = get_cache(domain);
925         struct cache_entry *centry = NULL;
926         NTSTATUS status;
927         fstring uname;
928         DOM_SID *sid2;
929
930         if (!cache->tdb)
931                 goto do_query;
932
933         fstrcpy(uname, name);
934         strupper_m(uname);
935         centry = wcache_fetch(cache, domain, "NS/%s/%s", domain->name, uname);
936         if (!centry)
937                 goto do_query;
938         *type = (enum SID_NAME_USE)centry_uint32(centry);
939         sid2 = centry_sid(centry, mem_ctx);
940         if (!sid2) {
941                 ZERO_STRUCTP(sid);
942         } else {
943                 sid_copy(sid, sid2);
944         }
945
946         status = centry->status;
947
948         DEBUG(10,("name_to_sid: [Cached] - cached name for domain %s status %s\n",
949                 domain->name, get_friendly_nt_error_msg(status) ));
950
951         centry_free(centry);
952         return status;
953
954 do_query:
955         ZERO_STRUCTP(sid);
956
957         /* If the seq number check indicated that there is a problem
958          * with this DC, then return that status... except for
959          * access_denied.  This is special because the dc may be in
960          * "restrict anonymous = 1" mode, in which case it will deny
961          * most unauthenticated operations, but *will* allow the LSA
962          * name-to-sid that we try as a fallback. */
963
964         if (!(NT_STATUS_IS_OK(domain->last_status)
965               || NT_STATUS_EQUAL(domain->last_status, NT_STATUS_ACCESS_DENIED)))
966                 return domain->last_status;
967
968         DEBUG(10,("name_to_sid: [Cached] - doing backend query for name for domain %s\n",
969                 domain->name ));
970
971         status = domain->backend->name_to_sid(domain, mem_ctx, name, sid, type);
972
973         /* and save it */
974         wcache_save_name_to_sid(domain, status, name, sid, *type);
975
976         /* We can't save the sid to name mapping as we don't know the
977            correct case of the name without looking it up */
978
979         return status;
980 }
981
982 /* convert a sid to a user or group name. The sid is guaranteed to be in the domain
983    given */
984 static NTSTATUS sid_to_name(struct winbindd_domain *domain,
985                             TALLOC_CTX *mem_ctx,
986                             const DOM_SID *sid,
987                             char **name,
988                             enum SID_NAME_USE *type)
989 {
990         struct winbind_cache *cache = get_cache(domain);
991         struct cache_entry *centry = NULL;
992         NTSTATUS status;
993         fstring sid_string;
994
995         if (!cache->tdb)
996                 goto do_query;
997
998         centry = wcache_fetch(cache, domain, "SN/%s", sid_to_string(sid_string, sid));
999         if (!centry)
1000                 goto do_query;
1001         if (NT_STATUS_IS_OK(centry->status)) {
1002                 *type = (enum SID_NAME_USE)centry_uint32(centry);
1003                 *name = centry_string(centry, mem_ctx);
1004         }
1005         status = centry->status;
1006
1007         DEBUG(10,("sid_to_name: [Cached] - cached name for domain %s status %s\n",
1008                 domain->name, get_friendly_nt_error_msg(status) ));
1009
1010         centry_free(centry);
1011         return status;
1012
1013 do_query:
1014         *name = NULL;
1015
1016         /* If the seq number check indicated that there is a problem
1017          * with this DC, then return that status... except for
1018          * access_denied.  This is special because the dc may be in
1019          * "restrict anonymous = 1" mode, in which case it will deny
1020          * most unauthenticated operations, but *will* allow the LSA
1021          * sid-to-name that we try as a fallback. */
1022
1023         if (!(NT_STATUS_IS_OK(domain->last_status)
1024               || NT_STATUS_EQUAL(domain->last_status, NT_STATUS_ACCESS_DENIED)))
1025                 return domain->last_status;
1026
1027         DEBUG(10,("sid_to_name: [Cached] - doing backend query for name for domain %s\n",
1028                 domain->name ));
1029
1030         status = domain->backend->sid_to_name(domain, mem_ctx, sid, name, type);
1031
1032         /* and save it */
1033         refresh_sequence_number(domain, False);
1034         wcache_save_sid_to_name(domain, status, sid, *name, *type);
1035         wcache_save_name_to_sid(domain, status, *name, sid, *type);
1036
1037         return status;
1038 }
1039
1040
1041 /* Lookup user information from a rid */
1042 static NTSTATUS query_user(struct winbindd_domain *domain, 
1043                            TALLOC_CTX *mem_ctx, 
1044                            const DOM_SID *user_sid, 
1045                            WINBIND_USERINFO *info)
1046 {
1047         struct winbind_cache *cache = get_cache(domain);
1048         struct cache_entry *centry = NULL;
1049         NTSTATUS status;
1050
1051         if (!cache->tdb)
1052                 goto do_query;
1053
1054         centry = wcache_fetch(cache, domain, "U/%s", sid_string_static(user_sid));
1055         
1056         /* If we have an access denied cache entry and a cached info3 in the
1057            samlogon cache then do a query.  This will force the rpc back end
1058            to return the info3 data. */
1059
1060         if (NT_STATUS_V(domain->last_status) == NT_STATUS_V(NT_STATUS_ACCESS_DENIED) &&
1061             netsamlogon_cache_have(user_sid)) {
1062                 DEBUG(10, ("query_user: cached access denied and have cached info3\n"));
1063                 domain->last_status = NT_STATUS_OK;
1064                 centry_free(centry);
1065                 goto do_query;
1066         }
1067         
1068         if (!centry)
1069                 goto do_query;
1070
1071         info->acct_name = centry_string(centry, mem_ctx);
1072         info->full_name = centry_string(centry, mem_ctx);
1073         info->user_sid = centry_sid(centry, mem_ctx);
1074         info->group_sid = centry_sid(centry, mem_ctx);
1075         status = centry->status;
1076
1077         DEBUG(10,("query_user: [Cached] - cached info for domain %s status %s\n",
1078                 domain->name, get_friendly_nt_error_msg(status) ));
1079
1080         centry_free(centry);
1081         return status;
1082
1083 do_query:
1084         ZERO_STRUCTP(info);
1085
1086         /* Return status value returned by seq number check */
1087
1088         if (!NT_STATUS_IS_OK(domain->last_status))
1089                 return domain->last_status;
1090         
1091         DEBUG(10,("sid_to_name: [Cached] - doing backend query for info for domain %s\n",
1092                 domain->name ));
1093
1094         status = domain->backend->query_user(domain, mem_ctx, user_sid, info);
1095
1096         /* and save it */
1097         refresh_sequence_number(domain, False);
1098         wcache_save_user(domain, status, info);
1099
1100         return status;
1101 }
1102
1103
1104 /* Lookup groups a user is a member of. */
1105 static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
1106                                   TALLOC_CTX *mem_ctx,
1107                                   const DOM_SID *user_sid, 
1108                                   uint32 *num_groups, DOM_SID ***user_gids)
1109 {
1110         struct winbind_cache *cache = get_cache(domain);
1111         struct cache_entry *centry = NULL;
1112         NTSTATUS status;
1113         unsigned int i;
1114         fstring sid_string;
1115
1116         if (!cache->tdb)
1117                 goto do_query;
1118
1119         centry = wcache_fetch(cache, domain, "UG/%s", sid_to_string(sid_string, user_sid));
1120         
1121         /* If we have an access denied cache entry and a cached info3 in the
1122            samlogon cache then do a query.  This will force the rpc back end
1123            to return the info3 data. */
1124
1125         if (NT_STATUS_V(domain->last_status) == NT_STATUS_V(NT_STATUS_ACCESS_DENIED) &&
1126             netsamlogon_cache_have(user_sid)) {
1127                 DEBUG(10, ("query_user: cached access denied and have cached info3\n"));
1128                 domain->last_status = NT_STATUS_OK;
1129                 centry_free(centry);
1130                 goto do_query;
1131         }
1132         
1133         if (!centry)
1134                 goto do_query;
1135
1136         *num_groups = centry_uint32(centry);
1137         
1138         if (*num_groups == 0)
1139                 goto do_cached;
1140
1141         (*user_gids) = talloc(mem_ctx, sizeof(**user_gids) * (*num_groups));
1142         if (! (*user_gids))
1143                 smb_panic("lookup_usergroups out of memory");
1144         for (i=0; i<(*num_groups); i++) {
1145                 (*user_gids)[i] = centry_sid(centry, mem_ctx);
1146         }
1147
1148 do_cached:      
1149         status = centry->status;
1150
1151         DEBUG(10,("lookup_usergroups: [Cached] - cached info for domain %s status %s\n",
1152                 domain->name, get_friendly_nt_error_msg(status) ));
1153
1154         centry_free(centry);
1155         return status;
1156
1157 do_query:
1158         (*num_groups) = 0;
1159         (*user_gids) = NULL;
1160
1161         /* Return status value returned by seq number check */
1162
1163         if (!NT_STATUS_IS_OK(domain->last_status))
1164                 return domain->last_status;
1165
1166         DEBUG(10,("lookup_usergroups: [Cached] - doing backend query for info for domain %s\n",
1167                 domain->name ));
1168
1169         status = domain->backend->lookup_usergroups(domain, mem_ctx, user_sid, num_groups, user_gids);
1170
1171         /* and save it */
1172         refresh_sequence_number(domain, False);
1173         centry = centry_start(domain, status);
1174         if (!centry)
1175                 goto skip_save;
1176         centry_put_uint32(centry, *num_groups);
1177         for (i=0; i<(*num_groups); i++) {
1178                 centry_put_sid(centry, (*user_gids)[i]);
1179         }       
1180         centry_end(centry, "UG/%s", sid_to_string(sid_string, user_sid));
1181         centry_free(centry);
1182
1183 skip_save:
1184         return status;
1185 }
1186
1187
1188 static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
1189                                 TALLOC_CTX *mem_ctx,
1190                                 const DOM_SID *group_sid, uint32 *num_names, 
1191                                 DOM_SID ***sid_mem, char ***names, 
1192                                 uint32 **name_types)
1193 {
1194         struct winbind_cache *cache = get_cache(domain);
1195         struct cache_entry *centry = NULL;
1196         NTSTATUS status;
1197         unsigned int i;
1198         fstring sid_string;
1199
1200         if (!cache->tdb)
1201                 goto do_query;
1202
1203         centry = wcache_fetch(cache, domain, "GM/%s", sid_to_string(sid_string, group_sid));
1204         if (!centry)
1205                 goto do_query;
1206
1207         *num_names = centry_uint32(centry);
1208         
1209         if (*num_names == 0)
1210                 goto do_cached;
1211
1212         (*sid_mem) = talloc(mem_ctx, sizeof(**sid_mem) * (*num_names));
1213         (*names) = talloc(mem_ctx, sizeof(**names) * (*num_names));
1214         (*name_types) = talloc(mem_ctx, sizeof(**name_types) * (*num_names));
1215
1216         if (! (*sid_mem) || ! (*names) || ! (*name_types)) {
1217                 smb_panic("lookup_groupmem out of memory");
1218         }
1219
1220         for (i=0; i<(*num_names); i++) {
1221                 (*sid_mem)[i] = centry_sid(centry, mem_ctx);
1222                 (*names)[i] = centry_string(centry, mem_ctx);
1223                 (*name_types)[i] = centry_uint32(centry);
1224         }
1225
1226 do_cached:      
1227         status = centry->status;
1228
1229         DEBUG(10,("lookup_groupmem: [Cached] - cached info for domain %s status %s\n",
1230                 domain->name, get_friendly_nt_error_msg(status) ));
1231
1232         centry_free(centry);
1233         return status;
1234
1235 do_query:
1236         (*num_names) = 0;
1237         (*sid_mem) = NULL;
1238         (*names) = NULL;
1239         (*name_types) = NULL;
1240         
1241         /* Return status value returned by seq number check */
1242
1243         if (!NT_STATUS_IS_OK(domain->last_status))
1244                 return domain->last_status;
1245
1246         DEBUG(10,("lookup_groupmem: [Cached] - doing backend query for info for domain %s\n",
1247                 domain->name ));
1248
1249         status = domain->backend->lookup_groupmem(domain, mem_ctx, group_sid, num_names, 
1250                                                   sid_mem, names, name_types);
1251
1252         /* and save it */
1253         refresh_sequence_number(domain, False);
1254         centry = centry_start(domain, status);
1255         if (!centry)
1256                 goto skip_save;
1257         centry_put_uint32(centry, *num_names);
1258         for (i=0; i<(*num_names); i++) {
1259                 centry_put_sid(centry, (*sid_mem)[i]);
1260                 centry_put_string(centry, (*names)[i]);
1261                 centry_put_uint32(centry, (*name_types)[i]);
1262         }       
1263         centry_end(centry, "GM/%s", sid_to_string(sid_string, group_sid));
1264         centry_free(centry);
1265
1266 skip_save:
1267         return status;
1268 }
1269
1270 /* find the sequence number for a domain */
1271 static NTSTATUS sequence_number(struct winbindd_domain *domain, uint32 *seq)
1272 {
1273         refresh_sequence_number(domain, False);
1274
1275         *seq = domain->sequence_number;
1276
1277         return NT_STATUS_OK;
1278 }
1279
1280 /* enumerate trusted domains */
1281 static NTSTATUS trusted_domains(struct winbindd_domain *domain,
1282                                 TALLOC_CTX *mem_ctx,
1283                                 uint32 *num_domains,
1284                                 char ***names,
1285                                 char ***alt_names,
1286                                 DOM_SID **dom_sids)
1287 {
1288         get_cache(domain);
1289
1290         DEBUG(10,("trusted_domains: [Cached] - doing backend query for info for domain %s\n",
1291                 domain->name ));
1292
1293         /* we don't cache this call */
1294         return domain->backend->trusted_domains(domain, mem_ctx, num_domains, 
1295                                                names, alt_names, dom_sids);
1296 }
1297
1298 /* find the domain sid */
1299 static NTSTATUS domain_sid(struct winbindd_domain *domain, DOM_SID *sid)
1300 {
1301         get_cache(domain);
1302
1303         DEBUG(10,("domain_sid: [Cached] - doing backend query for info for domain %s\n",
1304                 domain->name ));
1305
1306         /* we don't cache this call */
1307         return domain->backend->domain_sid(domain, sid);
1308 }
1309
1310 /* find the alternate names for the domain, if any */
1311 static NTSTATUS alternate_name(struct winbindd_domain *domain)
1312 {
1313         get_cache(domain);
1314
1315         DEBUG(10,("alternate_name: [Cached] - doing backend query for info for domain %s\n",
1316                 domain->name ));
1317
1318         /* we don't cache this call */
1319         return domain->backend->alternate_name(domain);
1320 }
1321
1322 /* Invalidate cached user and group lists coherently */
1323
1324 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, 
1325                        void *state)
1326 {
1327         if (strncmp(kbuf.dptr, "UL/", 3) == 0 ||
1328             strncmp(kbuf.dptr, "GL/", 3) == 0)
1329                 tdb_delete(the_tdb, kbuf);
1330
1331         return 0;
1332 }
1333
1334 /* Invalidate the getpwnam and getgroups entries for a winbindd domain */
1335
1336 void wcache_invalidate_samlogon(struct winbindd_domain *domain, 
1337                                 NET_USER_INFO_3 *info3)
1338 {
1339         struct winbind_cache *cache;
1340         
1341         if (!domain)
1342                 return;
1343
1344         cache = get_cache(domain);
1345         netsamlogon_clear_cached_user(cache->tdb, info3);
1346 }
1347
1348 void wcache_invalidate_cache(void)
1349 {
1350         struct winbindd_domain *domain;
1351
1352         for (domain = domain_list(); domain; domain = domain->next) {
1353                 struct winbind_cache *cache = get_cache(domain);
1354
1355                 DEBUG(10, ("wcache_invalidate_cache: invalidating cache "
1356                            "entries for %s\n", domain->name));
1357                 if (cache)
1358                         tdb_traverse(cache->tdb, traverse_fn, NULL);
1359         }
1360 }
1361
1362 /* the ADS backend methods are exposed via this structure */
1363 struct winbindd_methods cache_methods = {
1364         True,
1365         query_user_list,
1366         enum_dom_groups,
1367         enum_local_groups,
1368         name_to_sid,
1369         sid_to_name,
1370         query_user,
1371         lookup_usergroups,
1372         lookup_groupmem,
1373         sequence_number,
1374         trusted_domains,
1375         domain_sid,
1376         alternate_name
1377 };