import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / libsmb / libsmb_cache.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB client library implementation (server cache)
4    Copyright (C) Andrew Tridgell 1998
5    Copyright (C) Richard Sharpe 2000
6    Copyright (C) John Terpstra 2000
7    Copyright (C) Tom Jansen (Ninja ISD) 2002 
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 "includes.h"
25
26 /*
27  * Define this to get the real SMBCFILE and SMBCSRV structures 
28  */
29 #define _SMBC_INTERNAL
30 #include "../include/libsmbclient.h"
31
32 /*
33  * Structure we use if internal caching mechanism is used 
34  * nothing fancy here.
35  */
36 struct smbc_server_cache {
37         char *server_name;
38         char *share_name;
39         char *workgroup;
40         char *username;
41         SMBCSRV *server;
42         
43         struct smbc_server_cache *next, *prev;
44 };
45         
46
47
48 /*
49  * Add a new connection to the server cache.
50  * This function is only used if the external cache is not enabled 
51  */
52 static int smbc_add_cached_server(SMBCCTX * context, SMBCSRV * new,
53                                   const char * server, const char * share, 
54                                   const char * workgroup, const char * username)
55 {
56         struct smbc_server_cache * srvcache = NULL;
57
58         if (!(srvcache = malloc(sizeof(*srvcache)))) {
59                 errno = ENOMEM;
60                 DEBUG(3, ("Not enough space for server cache allocation\n"));
61                 return 1;
62         }
63        
64         ZERO_STRUCTP(srvcache);
65
66         srvcache->server = new;
67
68         srvcache->server_name = strdup(server);
69         if (!srvcache->server_name) {
70                 errno = ENOMEM;
71                 goto failed;
72         }
73
74         srvcache->share_name = strdup(share);
75         if (!srvcache->share_name) {
76                 errno = ENOMEM;
77                 goto failed;
78         }
79
80         srvcache->workgroup = strdup(workgroup);
81         if (!srvcache->workgroup) {
82                 errno = ENOMEM;
83                 goto failed;
84         }
85
86         srvcache->username = strdup(username);
87         if (!srvcache->username) {
88                 errno = ENOMEM;
89                 goto failed;
90         }
91
92         DLIST_ADD((context->server_cache), srvcache);
93         return 0;
94
95  failed:
96         SAFE_FREE(srvcache->server_name);
97         SAFE_FREE(srvcache->share_name);
98         SAFE_FREE(srvcache->workgroup);
99         SAFE_FREE(srvcache->username);
100         
101         return 1;
102 }
103
104
105
106 /*
107  * Search the server cache for a server 
108  * returns server_fd on success, -1 on error (not found)
109  * This function is only used if the external cache is not enabled 
110  */
111 static SMBCSRV * smbc_get_cached_server(SMBCCTX * context, const char * server, 
112                                   const char * share, const char * workgroup, const char * user)
113 {
114         struct smbc_server_cache * srv = NULL;
115         
116         /* Search the cache lines */
117         for (srv=((struct smbc_server_cache *)context->server_cache);srv;srv=srv->next) {
118                 if (strcmp(server,srv->server_name)  == 0 &&
119                     strcmp(share,srv->share_name)    == 0 &&
120                     strcmp(workgroup,srv->workgroup) == 0 &&
121                     strcmp(user, srv->username)  == 0) 
122                         return srv->server;
123         }
124
125         return NULL;
126 }
127
128
129 /* 
130  * Search the server cache for a server and remove it
131  * returns 0 on success
132  * This function is only used if the external cache is not enabled 
133  */
134 static int smbc_remove_cached_server(SMBCCTX * context, SMBCSRV * server)
135 {
136         struct smbc_server_cache * srv = NULL;
137         
138         for (srv=((struct smbc_server_cache *)context->server_cache);srv;srv=srv->next) {
139                 if (server == srv->server) { 
140
141                         /* remove this sucker */
142                         DLIST_REMOVE(context->server_cache, srv);
143                         SAFE_FREE(srv->server_name);
144                         SAFE_FREE(srv->share_name);
145                         SAFE_FREE(srv->workgroup);
146                         SAFE_FREE(srv->username);
147                         SAFE_FREE(srv);
148                         return 0;
149                 }
150         }
151         /* server not found */
152         return 1;
153 }
154
155
156 /*
157  * Try to remove all the servers in cache
158  * returns 1 on failure and 0 if all servers could be removed.
159  */
160 static int smbc_purge_cached(SMBCCTX * context)
161 {
162         struct smbc_server_cache * srv;
163         struct smbc_server_cache * next;
164         int could_not_purge_all = 0;
165
166         for (srv = ((struct smbc_server_cache *) context->server_cache),
167                  next = (srv ? srv->next :NULL);
168              srv;
169              srv = next, next = (srv ? srv->next : NULL)) {
170
171                 if (smbc_remove_unused_server(context, srv->server)) {
172                         /* could not be removed */
173                         could_not_purge_all = 1;
174                 }
175         }
176         return could_not_purge_all;
177 }
178
179
180
181 /*
182  * This functions initializes all server-cache related functions 
183  * to the default (internal) system.
184  *
185  * We use this to make the rest of the cache system static.
186  */
187
188 int smbc_default_cache_functions(SMBCCTX * context)
189 {
190         context->callbacks.add_cached_srv_fn    = smbc_add_cached_server;
191         context->callbacks.get_cached_srv_fn    = smbc_get_cached_server;
192         context->callbacks.remove_cached_srv_fn = smbc_remove_cached_server;
193         context->callbacks.purge_cached_fn      = smbc_purge_cached;
194
195         return 0;
196 }