import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / passdb / login_cache.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SAM_ACCOUNT local cache for 
4    Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2004.
5       
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 #undef DBGC_CLASS
24 #define DBGC_CLASS DBGC_PASSDB
25
26 #define LOGIN_CACHE_FILE "login_cache.tdb"
27
28 #define SAM_CACHE_FORMAT "dwwd"
29
30 static TDB_CONTEXT *cache;
31
32 BOOL login_cache_init(void)
33 {
34         char* cache_fname = NULL;
35         
36         /* skip file open if it's already opened */
37         if (cache) return True;
38
39         asprintf(&cache_fname, "%s/%s", lp_lockdir(), LOGIN_CACHE_FILE);
40         if (cache_fname)
41                 DEBUG(5, ("Opening cache file at %s\n", cache_fname));
42         else {
43                 DEBUG(0, ("Filename allocation failed.\n"));
44                 return False;
45         }
46
47         cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT,
48                              O_RDWR|O_CREAT, 0644);
49
50         if (!cache)
51                 DEBUG(5, ("Attempt to open %s failed.\n", cache_fname));
52
53         SAFE_FREE(cache_fname);
54
55         return (cache ? True : False);
56 }
57
58 BOOL login_cache_shutdown(void)
59 {
60         /* tdb_close routine returns -1 on error */
61         if (!cache) return False;
62         DEBUG(5, ("Closing cache file\n"));
63         return tdb_close(cache) != -1;
64 }
65
66 /* if we can't read the cache, oh well, no need to return anything */
67 LOGIN_CACHE * login_cache_read(SAM_ACCOUNT *sampass)
68 {
69         TDB_DATA keybuf, databuf;
70         LOGIN_CACHE *entry;
71
72         if (!login_cache_init())
73                 return NULL;
74
75         keybuf.dptr = strdup(pdb_get_nt_username(sampass));
76         if (!keybuf.dptr || !strlen(keybuf.dptr)) {
77                 SAFE_FREE(keybuf.dptr);
78                 return NULL;
79         }
80         keybuf.dsize = strlen(keybuf.dptr) + 1;
81
82         DEBUG(7, ("Looking up login cache for user %s\n",
83                   keybuf.dptr));
84         databuf = tdb_fetch(cache, keybuf);
85         SAFE_FREE(keybuf.dptr);
86
87         if (!(entry = malloc(sizeof(LOGIN_CACHE)))) {
88                 DEBUG(1, ("Unable to allocate cache entry buffer!\n"));
89                 SAFE_FREE(databuf.dptr);
90                 return NULL;
91         }
92
93         if (tdb_unpack (databuf.dptr, databuf.dsize, SAM_CACHE_FORMAT,
94                         &entry->entry_timestamp, &entry->acct_ctrl, 
95                         &entry->bad_password_count, 
96                         &entry->bad_password_time) == -1) {
97                 DEBUG(7, ("No cache entry found\n"));
98                 SAFE_FREE(databuf.dptr);
99                 return NULL;
100         }
101
102         DEBUG(5, ("Found login cache entry: timestamp %12u, flags 0x%x, count %d, time %12u\n",
103                   entry->entry_timestamp, entry->acct_ctrl, 
104                   entry->bad_password_count, entry->bad_password_time));
105         return entry;
106 }
107
108 BOOL login_cache_write(const SAM_ACCOUNT *sampass, LOGIN_CACHE entry)
109 {
110
111         TDB_DATA keybuf, databuf;
112         BOOL ret;
113         
114
115         keybuf.dptr = strdup(pdb_get_nt_username(sampass));
116         if (!keybuf.dptr || !strlen(keybuf.dptr)) {
117                 SAFE_FREE(keybuf.dptr);
118                 return False;
119         }
120         keybuf.dsize = strlen(keybuf.dptr) + 1;
121
122         entry.entry_timestamp = time(NULL);
123
124         databuf.dsize = 
125                 tdb_pack(NULL, 0, SAM_CACHE_FORMAT,
126                          entry.entry_timestamp,
127                          entry.acct_ctrl,
128                          entry.bad_password_count,
129                          entry.bad_password_time);
130         databuf.dptr = malloc(databuf.dsize);
131         if (!databuf.dptr) {
132                 SAFE_FREE(keybuf.dptr);
133                 return False;
134         }
135                          
136         if (tdb_pack(databuf.dptr, databuf.dsize, SAM_CACHE_FORMAT,
137                          entry.entry_timestamp,
138                          entry.acct_ctrl,
139                          entry.bad_password_count,
140                          entry.bad_password_time)
141             != databuf.dsize) {
142                 SAFE_FREE(keybuf.dptr);
143                 SAFE_FREE(databuf.dptr);
144                 return False;
145         }
146
147         ret = tdb_store(cache, keybuf, databuf, 0);
148         SAFE_FREE(keybuf.dptr);
149         SAFE_FREE(databuf.dptr);
150         return ret == 0;
151 }
152
153 BOOL login_cache_delentry(const SAM_ACCOUNT *sampass)
154 {
155         int ret;
156         TDB_DATA keybuf;
157         
158         if (!login_cache_init()) 
159                 return False;   
160
161         keybuf.dptr = strdup(pdb_get_nt_username(sampass));
162         if (!keybuf.dptr || !strlen(keybuf.dptr)) {
163                 SAFE_FREE(keybuf.dptr);
164                 return False;
165         }
166         keybuf.dsize = strlen(keybuf.dptr) + 1;
167         DEBUG(9, ("About to delete entry for %s\n", keybuf.dptr));
168         ret = tdb_delete(cache, keybuf);
169         DEBUG(9, ("tdb_delete returned %d\n", ret));
170         
171         SAFE_FREE(keybuf.dptr);
172         return ret == 0;
173 }
174