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 3 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, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "libsmb/libsmb.h"
25 #include "libsmbclient.h"
26 #include "libsmb_internal.h"
27
28 /*
29 * Structure we use if internal caching mechanism is used
30 * nothing fancy here.
31 */
32 struct smbc_server_cache {
33 char *server_name;
34 char *share_name;
35 char *workgroup;
36 char *username;
37 SMBCSRV *server;
38
39 struct smbc_server_cache *next, *prev;
40 };
41
42
43
44 /*
45 * Add a new connection to the server cache.
46 * This function is only used if the external cache is not enabled
47 */
48 int
SMBC_add_cached_server(SMBCCTX * context,SMBCSRV * newsrv,const char * server,const char * share,const char * workgroup,const char * username)49 SMBC_add_cached_server(SMBCCTX * context,
50 SMBCSRV * newsrv,
51 const char * server,
52 const char * share,
53 const char * workgroup,
54 const char * username)
55 {
56 struct smbc_server_cache * srvcache = NULL;
57
58 if (!(srvcache = SMB_MALLOC_P(struct smbc_server_cache))) {
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 = newsrv;
67
68 srvcache->server_name = SMB_STRDUP(server);
69 if (!srvcache->server_name) {
70 errno = ENOMEM;
71 goto failed;
72 }
73
74 srvcache->share_name = SMB_STRDUP(share);
75 if (!srvcache->share_name) {
76 errno = ENOMEM;
77 goto failed;
78 }
79
80 srvcache->workgroup = SMB_STRDUP(workgroup);
81 if (!srvcache->workgroup) {
82 errno = ENOMEM;
83 goto failed;
84 }
85
86 srvcache->username = SMB_STRDUP(username);
87 if (!srvcache->username) {
88 errno = ENOMEM;
89 goto failed;
90 }
91
92 DLIST_ADD(context->internal->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 SAFE_FREE(srvcache);
101
102 return 1;
103 }
104
105
106
107 /*
108 * Search the server cache for a server
109 * returns server handle on success, NULL on error (not found)
110 * This function is only used if the external cache is not enabled
111 */
112 SMBCSRV *
SMBC_get_cached_server(SMBCCTX * context,const char * server,const char * share,const char * workgroup,const char * user)113 SMBC_get_cached_server(SMBCCTX * context,
114 const char * server,
115 const char * share,
116 const char * workgroup,
117 const char * user)
118 {
119 struct smbc_server_cache * srv = NULL;
120
121 /* Search the cache lines */
122 for (srv = context->internal->server_cache; srv; srv = srv->next) {
123
124 if (strcmp(server,srv->server_name) == 0 &&
125 strcmp(workgroup,srv->workgroup) == 0 &&
126 strcmp(user, srv->username) == 0) {
127
128 /* If the share name matches, we're cool */
129 if (strcmp(share, srv->share_name) == 0) {
130 return srv->server;
131 }
132
133 /*
134 * We only return an empty share name or the attribute
135 * server on an exact match (which would have been
136 * caught above).
137 */
138 if (*share == '\0' || strcmp(share, "*IPC$") == 0)
139 continue;
140
141 /*
142 * Never return an empty share name or the attribute
143 * server if it wasn't what was requested.
144 */
145 if (*srv->share_name == '\0' ||
146 strcmp(srv->share_name, "*IPC$") == 0)
147 continue;
148
149 /*
150 * If we're only allowing one share per server, then
151 * a connection to the server (other than the
152 * attribute server connection) is cool.
153 */
154 if (smbc_getOptionOneSharePerServer(context)) {
155 NTSTATUS status;
156 /*
157 * The currently connected share name
158 * doesn't match the requested share, so
159 * disconnect from the current share.
160 */
161 status = cli_tdis(srv->server->cli);
162 if (!NT_STATUS_IS_OK(status)) {
163 /* Sigh. Couldn't disconnect. */
164 cli_shutdown(srv->server->cli);
165 srv->server->cli = NULL;
166 smbc_getFunctionRemoveCachedServer(context)(context, srv->server);
167 continue;
168 }
169
170 /*
171 * Save the new share name. We've
172 * disconnected from the old share, and are
173 * about to connect to the new one.
174 */
175 SAFE_FREE(srv->share_name);
176 srv->share_name = SMB_STRDUP(share);
177 if (!srv->share_name) {
178 /* Out of memory. */
179 cli_shutdown(srv->server->cli);
180 srv->server->cli = NULL;
181 smbc_getFunctionRemoveCachedServer(context)(context, srv->server);
182 continue;
183 }
184
185 return srv->server;
186 }
187 }
188 }
189
190 return NULL;
191 }
192
193
194 /*
195 * Search the server cache for a server and remove it
196 * returns 0 on success
197 * This function is only used if the external cache is not enabled
198 */
199 int
SMBC_remove_cached_server(SMBCCTX * context,SMBCSRV * server)200 SMBC_remove_cached_server(SMBCCTX * context,
201 SMBCSRV * server)
202 {
203 struct smbc_server_cache * srv = NULL;
204
205 for (srv = context->internal->server_cache; srv; srv = srv->next) {
206 if (server == srv->server) {
207
208 /* remove this sucker */
209 DLIST_REMOVE(context->internal->server_cache, srv);
210 SAFE_FREE(srv->server_name);
211 SAFE_FREE(srv->share_name);
212 SAFE_FREE(srv->workgroup);
213 SAFE_FREE(srv->username);
214 SAFE_FREE(srv);
215 return 0;
216 }
217 }
218 /* server not found */
219 return 1;
220 }
221
222
223 /*
224 * Try to remove all the servers in cache
225 * returns 1 on failure and 0 if all servers could be removed.
226 */
227 int
SMBC_purge_cached_servers(SMBCCTX * context)228 SMBC_purge_cached_servers(SMBCCTX * context)
229 {
230 struct smbc_server_cache * srv;
231 struct smbc_server_cache * next;
232 int could_not_purge_all = 0;
233
234 for (srv = context->internal->server_cache,
235 next = (srv ? srv->next :NULL);
236 srv;
237 srv = next,
238 next = (srv ? srv->next : NULL)) {
239
240 if (SMBC_remove_unused_server(context, srv->server)) {
241 /* could not be removed */
242 could_not_purge_all = 1;
243 }
244 }
245 return could_not_purge_all;
246 }
247