Fix from John for growing messages.tdb.
[ira/wip.git] / source3 / nsswitch / winbindd_cache.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.0
4
5    Winbind daemon - caching related functions
6
7    Copyright (C) Tim Potter 2000
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "winbindd.h"
25
26 #define CACHE_TYPE_USER "USR"
27 #define CACHE_TYPE_GROUP "GRP"
28
29 /* Initialise caching system */
30
31 static TDB_CONTEXT *cache_tdb;
32
33 struct cache_rec {
34         uint32 seq_num;
35         time_t mod_time;
36 };
37
38 void winbindd_cache_init(void)
39 {
40         /* Open tdb cache */
41         unlink(lock_path("winbindd_cache.tdb"));
42         if (!(cache_tdb = tdb_open(lock_path("winbindd_cache.tdb"), 0, 
43                                    TDB_NOLOCK,
44                                    O_RDWR | O_CREAT, 0600))) {
45                 DEBUG(0, ("Unable to open tdb cache - user and group caching "
46                           "disabled\n"));
47         }
48 }
49
50 /* get the domain sequence number, possibly re-fetching */
51 static uint32 cached_sequence_number(char *domain_name)
52 {
53         fstring keystr;
54         TDB_DATA dbuf;
55         struct cache_rec rec;
56         time_t t = time(NULL);
57
58         slprintf(keystr, sizeof(keystr), "CACHESEQ/%s", domain_name);
59         dbuf = tdb_fetch_by_string(cache_tdb, keystr);
60         if (!dbuf.dptr || dbuf.dsize != sizeof(rec)) {
61                 goto refetch;
62         }
63         memcpy(&rec, dbuf.dptr, sizeof(rec));
64         free(dbuf.dptr);
65
66         if (t < (rec.mod_time + lp_winbind_cache_time())) {
67                 DEBUG(4,("cached sequence number for %s is %u\n",
68                          domain_name, (unsigned)rec.seq_num));
69                 return rec.seq_num;
70         }
71
72  refetch:       
73         rec.seq_num = domain_sequence_number(domain_name);
74         rec.mod_time = t;
75         tdb_store_by_string(cache_tdb, keystr, &rec, sizeof(rec));
76
77         return rec.seq_num;
78 }
79
80 /* Check whether a seq_num for a cached item has expired */
81 static BOOL cache_domain_expired(char *domain_name, uint32 seq_num)
82 {
83         if (cached_sequence_number(domain_name) != seq_num) {
84                 DEBUG(4,("seq %u for %s has expired\n", (unsigned)seq_num, domain_name));
85                 return True;
86         }
87         return False;
88 }
89
90 static void set_cache_sequence_number(char *domain_name, char *cache_type, char *subkey)
91 {
92         fstring keystr;
93         slprintf(keystr,sizeof(keystr),"CACHESEQ %s/%s/%s",
94                  domain_name, cache_type, subkey?subkey:"");
95         tdb_store_int(cache_tdb, keystr, cached_sequence_number(domain_name));
96 }
97
98 static uint32 get_cache_sequence_number(char *domain_name, char *cache_type, char *subkey)
99 {
100         fstring keystr;
101         uint32 seq_num;
102         slprintf(keystr,sizeof(keystr),"CACHESEQ %s/%s/%s",
103                  domain_name, cache_type, subkey?subkey:"");
104         seq_num = (uint32)tdb_fetch_int(cache_tdb, keystr);
105         DEBUG(4,("%s is %u\n", keystr, (unsigned)seq_num));
106         return seq_num;
107 }
108
109 /* Fill the user or group cache with supplied data */
110 static void fill_cache(char *domain_name, char *cache_type,
111                        struct acct_info *sam_entries,
112                        int num_sam_entries)
113 {
114         fstring keystr;
115
116         if (lp_winbind_cache_time() == 0) return;
117
118         /* Error check */
119         if (!sam_entries || (num_sam_entries == 0)) return;
120
121         DEBUG(4, ("filling %s cache for domain %s with %d entries\n",
122                   cache_type, domain_name, num_sam_entries));
123
124         /* Store data as a mega-huge chunk in the tdb */
125         slprintf(keystr, sizeof(keystr), "%s CACHE DATA/%s", cache_type,
126                  domain_name);
127
128         tdb_store_by_string(cache_tdb, keystr, 
129                             sam_entries, sizeof(struct acct_info) * num_sam_entries);
130
131         /* Stamp cache with current seq number */
132         set_cache_sequence_number(domain_name, cache_type, NULL);
133 }
134
135 /* Fill the user cache with supplied data */
136
137 void winbindd_fill_user_cache(char *domain_name, 
138                               struct acct_info *sam_entries,
139                               int num_sam_entries)
140 {
141         fill_cache(domain_name, CACHE_TYPE_USER, sam_entries, num_sam_entries);
142 }
143
144 /* Fill the group cache with supplied data */
145
146 void winbindd_fill_group_cache(char *domain_name,
147                                struct acct_info *sam_entries,
148                                int num_sam_entries)
149 {
150         fill_cache(domain_name, CACHE_TYPE_GROUP, sam_entries, num_sam_entries);
151 }
152
153 static void fill_cache_entry(char *domain, char *cache_type, char *name, void *buf, int len)
154 {
155         fstring keystr;
156
157         /* Create key for store */
158         slprintf(keystr, sizeof(keystr), "%s/%s/%s", cache_type, domain, name);
159
160         DEBUG(4, ("filling cache entry %s\n", keystr));
161
162         /* Store it */
163         tdb_store_by_string(cache_tdb, keystr, buf, len);
164 }
165
166 /* Fill a user info cache entry */
167 void winbindd_fill_user_cache_entry(char *domain, char *user_name, 
168                                     struct winbindd_pw *pw)
169 {
170         if (lp_winbind_cache_time() == 0) return;
171
172         fill_cache_entry(domain, CACHE_TYPE_USER, user_name, pw, sizeof(struct winbindd_pw));
173         set_cache_sequence_number(domain, CACHE_TYPE_USER, user_name);
174 }
175
176 /* Fill a user uid cache entry */
177 void winbindd_fill_uid_cache_entry(char *domain, uid_t uid, 
178                                     struct winbindd_pw *pw)
179 {
180         fstring uidstr;
181
182         if (lp_winbind_cache_time() == 0) return;
183
184         slprintf(uidstr, sizeof(uidstr), "#%u", (unsigned)uid);
185         fill_cache_entry(domain, CACHE_TYPE_USER, uidstr, pw, sizeof(struct winbindd_pw));
186         set_cache_sequence_number(domain, CACHE_TYPE_USER, uidstr);
187 }
188
189 /* Fill a group info cache entry */
190 void winbindd_fill_group_cache_entry(char *domain, char *group_name, 
191                                      struct winbindd_gr *gr, void *extra_data,
192                                      int extra_data_len)
193 {
194         fstring keystr;
195
196         if (lp_winbind_cache_time() == 0) return;
197
198         /* Fill group data */
199         fill_cache_entry(domain, CACHE_TYPE_GROUP, group_name, gr, sizeof(struct winbindd_gr));
200
201         /* Fill extra data */
202         slprintf(keystr, sizeof(keystr), "%s/%s/%s DATA", CACHE_TYPE_GROUP, domain, group_name);
203         tdb_store_by_string(cache_tdb, keystr, extra_data, extra_data_len);
204
205         set_cache_sequence_number(domain, CACHE_TYPE_GROUP, group_name);
206 }
207
208 /* Fill a group info cache entry */
209 void winbindd_fill_gid_cache_entry(char *domain, gid_t gid, 
210                                      struct winbindd_gr *gr, void *extra_data,
211                                      int extra_data_len)
212 {
213         fstring keystr;
214         fstring gidstr;
215
216         slprintf(gidstr, sizeof(gidstr), "#%u", (unsigned)gid);
217
218         if (lp_winbind_cache_time() == 0) return;
219
220         /* Fill group data */
221         fill_cache_entry(domain, CACHE_TYPE_GROUP, gidstr, gr, sizeof(struct winbindd_gr));
222
223         /* Fill extra data */
224         slprintf(keystr, sizeof(keystr), "%s/%s/%s DATA", CACHE_TYPE_GROUP, domain, gidstr);
225         tdb_store_by_string(cache_tdb, keystr, extra_data, extra_data_len);
226
227         set_cache_sequence_number(domain, CACHE_TYPE_GROUP, gidstr);
228 }
229
230 /* Fetch some cached user or group data */
231 static BOOL fetch_cache(char *domain_name, char *cache_type,
232                         struct acct_info **sam_entries, int *num_sam_entries)
233 {
234         TDB_DATA data;
235         fstring keystr;
236
237         if (lp_winbind_cache_time() == 0) return False;
238
239         /* Parameter check */
240         if (!sam_entries || !num_sam_entries) {
241                 return False;
242         }
243
244         /* Check cache data is current */
245         if (cache_domain_expired(domain_name, 
246                                  get_cache_sequence_number(domain_name, cache_type, NULL))) {
247                 return False;
248         }
249         
250         /* Create key */        
251         slprintf(keystr, sizeof(keystr), "%s CACHE DATA/%s", cache_type,
252                  domain_name);
253         
254         /* Fetch cache information */
255         data = tdb_fetch_by_string(cache_tdb, keystr);
256         
257         if (!data.dptr) return False;
258
259         /* Copy across cached data.  We can save a memcpy() by directly
260            assigning the data.dptr to the sam_entries pointer.  It will
261            be freed by the end{pw,gr}ent() function. */
262         
263         *sam_entries = (struct acct_info *)data.dptr;
264         *num_sam_entries = data.dsize / sizeof(struct acct_info);
265         
266         DEBUG(4, ("fetched %d cached %s entries for domain %s\n",
267                   *num_sam_entries, cache_type, domain_name));
268         
269         return True;
270 }
271
272 /* Return cached entries for a domain.  Return false if there are no cached
273    entries, or the cached information has expired for the domain. */
274
275 BOOL winbindd_fetch_user_cache(char *domain_name,
276                                struct acct_info **sam_entries,
277                                int *num_entries)
278 {
279         return fetch_cache(domain_name, CACHE_TYPE_USER, sam_entries,
280                            num_entries);
281 }
282
283 /* Return cached entries for a domain.  Return false if there are no cached
284    entries, or the cached information has expired for the domain. */
285
286 BOOL winbindd_fetch_group_cache(char *domain_name,
287                                 struct acct_info **sam_entries,
288                                 int *num_entries)
289 {
290         return fetch_cache(domain_name, CACHE_TYPE_GROUP, sam_entries,
291                            num_entries);
292 }
293
294 static BOOL fetch_cache_entry(char *domain, char *cache_type, char *name, void *buf, int len)
295 {
296         TDB_DATA data;
297         fstring keystr;
298     
299         /* Create key for lookup */
300         slprintf(keystr, sizeof(keystr), "%s/%s/%s", cache_type, domain, name);
301     
302         /* Look up cache entry */
303         data = tdb_fetch_by_string(cache_tdb, keystr);
304         if (!data.dptr) return False;
305         
306         DEBUG(4, ("returning cached entry for %s\\%s\n", domain, name));
307
308         /* Copy found entry into buffer */        
309         memcpy((char *)buf, data.dptr, len < data.dsize ? len : data.dsize);
310         free(data.dptr);
311         return True;
312 }
313
314 /* Fetch an individual user cache entry */
315 BOOL winbindd_fetch_user_cache_entry(char *domain_name, char *user, 
316                                      struct winbindd_pw *pw)
317 {
318         uint32 seq_num;
319
320         if (lp_winbind_cache_time() == 0) return False;
321
322         seq_num = get_cache_sequence_number(domain_name, CACHE_TYPE_USER, user);
323         if (cache_domain_expired(domain_name, seq_num)) return False;
324
325         return fetch_cache_entry(domain_name, CACHE_TYPE_USER, user, pw, sizeof(struct winbindd_pw));
326 }
327
328 /* Fetch an individual uid cache entry */
329 BOOL winbindd_fetch_uid_cache_entry(char *domain_name, uid_t uid, 
330                                     struct winbindd_pw *pw)
331 {
332         fstring uidstr;
333         uint32 seq_num;
334
335         if (lp_winbind_cache_time() == 0) return False;
336
337         slprintf(uidstr, sizeof(uidstr), "#%u", (unsigned)uid);
338         seq_num = get_cache_sequence_number(domain_name, CACHE_TYPE_USER, uidstr);
339         if (cache_domain_expired(domain_name, seq_num)) return False;
340
341         return fetch_cache_entry(domain_name, CACHE_TYPE_USER, uidstr, pw, sizeof(struct winbindd_pw));
342 }
343
344 /* Fetch an individual group cache entry.  This function differs from the
345    user cache code as we need to store the group membership data. */
346
347 BOOL winbindd_fetch_group_cache_entry(char *domain_name, char *group, 
348                                       struct winbindd_gr *gr,
349                                       void **extra_data, int *extra_data_len)
350 {
351         TDB_DATA data;
352         fstring keystr;
353         uint32 seq_num;
354
355         if (lp_winbind_cache_time() == 0) return False;
356
357         seq_num = get_cache_sequence_number(domain_name, CACHE_TYPE_GROUP, group);
358         if (cache_domain_expired(domain_name, seq_num)) return False;
359
360         /* Fetch group data */
361         if (!fetch_cache_entry(domain_name, CACHE_TYPE_GROUP, group, gr, sizeof(struct winbindd_gr))) return False;
362         
363         /* Fetch extra data */
364         slprintf(keystr, sizeof(keystr), "%s/%s/%s DATA", CACHE_TYPE_GROUP, domain_name, group);
365         data = tdb_fetch_by_string(cache_tdb, keystr);
366
367         if (!data.dptr) return False;
368
369         /* Extra data freed when data has been sent */
370         if (extra_data) *extra_data = data.dptr;
371         if (extra_data_len) *extra_data_len = data.dsize;
372         
373         return True;
374 }
375
376
377 /* Fetch an individual gid cache entry.  This function differs from the
378    user cache code as we need to store the group membership data. */
379
380 BOOL winbindd_fetch_gid_cache_entry(char *domain_name, gid_t gid,
381                                     struct winbindd_gr *gr,
382                                     void **extra_data, int *extra_data_len)
383 {
384         TDB_DATA data;
385         fstring keystr;
386         fstring gidstr;
387         uint32 seq_num;
388
389         slprintf(gidstr, sizeof(gidstr), "#%u", (unsigned)gid);
390         
391         if (lp_winbind_cache_time() == 0) return False;
392
393         seq_num = get_cache_sequence_number(domain_name, CACHE_TYPE_GROUP, gidstr);
394         if (cache_domain_expired(domain_name, seq_num)) return False;
395
396         /* Fetch group data */
397         if (!fetch_cache_entry(domain_name, CACHE_TYPE_GROUP, 
398                                gidstr, gr, sizeof(struct winbindd_gr))) return False;
399
400         /* Fetch extra data */
401         slprintf(keystr, sizeof(keystr), "%s/%s/%s DATA", CACHE_TYPE_GROUP, domain_name, gidstr);
402         data = tdb_fetch_by_string(cache_tdb, keystr);
403         if (!data.dptr) return False;
404
405         /* Extra data freed when data has been sent */
406         if (extra_data) *extra_data = data.dptr;
407         if (extra_data_len) *extra_data_len = data.dsize;
408
409         return True;
410 }
411
412 /* Flush cache data - easiest to just reopen the tdb */
413 void winbindd_flush_cache(void)
414 {
415         tdb_close(cache_tdb);
416         winbindd_cache_init();
417 }