Line data    Source code

       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
      49           0 : 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           0 :         struct smbc_server_cache * srvcache = NULL;
      57             : 
      58           0 :         if (!(srvcache = SMB_MALLOC_P(struct smbc_server_cache))) {
      59           0 :                 errno = ENOMEM;
      60           0 :                 DEBUG(3, ("Not enough space for server cache allocation\n"));
      61           0 :                 return 1;
      62             :         }
      63             : 
      64           0 :         ZERO_STRUCTP(srvcache);
      65             : 
      66           0 :         srvcache->server = newsrv;
      67             : 
      68           0 :         srvcache->server_name = SMB_STRDUP(server);
      69           0 :         if (!srvcache->server_name) {
      70           0 :                 errno = ENOMEM;
      71           0 :                 goto failed;
      72             :         }
      73             : 
      74           0 :         srvcache->share_name = SMB_STRDUP(share);
      75           0 :         if (!srvcache->share_name) {
      76           0 :                 errno = ENOMEM;
      77           0 :                 goto failed;
      78             :         }
      79             : 
      80           0 :         srvcache->workgroup = SMB_STRDUP(workgroup);
      81           0 :         if (!srvcache->workgroup) {
      82           0 :                 errno = ENOMEM;
      83           0 :                 goto failed;
      84             :         }
      85             : 
      86           0 :         srvcache->username = SMB_STRDUP(username);
      87           0 :         if (!srvcache->username) {
      88           0 :                 errno = ENOMEM;
      89           0 :                 goto failed;
      90             :         }
      91             : 
      92           0 :         DLIST_ADD(context->internal->server_cache, srvcache);
      93           0 :         return 0;
      94             : 
      95           0 : failed:
      96           0 :         SAFE_FREE(srvcache->server_name);
      97           0 :         SAFE_FREE(srvcache->share_name);
      98           0 :         SAFE_FREE(srvcache->workgroup);
      99           0 :         SAFE_FREE(srvcache->username);
     100           0 :         SAFE_FREE(srvcache);
     101             : 
     102           0 :         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 *
     113           0 : SMBC_get_cached_server(SMBCCTX * context,
     114             :                        const char * server,
     115             :                        const char * share,
     116             :                        const char * workgroup,
     117             :                        const char * user)
     118             : {
     119           0 :         struct smbc_server_cache * srv = NULL;
     120             : 
     121             :         /* Search the cache lines */
     122           0 :         for (srv = context->internal->server_cache; srv; srv = srv->next) {
     123             : 
     124           0 :                 if (strcmp(server,srv->server_name)  == 0 &&
     125           0 :                     strcmp(workgroup,srv->workgroup) == 0 &&
     126           0 :                     strcmp(user, srv->username)  == 0) {
     127             : 
     128             :                         /* If the share name matches, we're cool */
     129           0 :                         if (strcmp(share, srv->share_name) == 0) {
     130           0 :                                 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           0 :                         if (*share == '\0' || strcmp(share, "*IPC$") == 0)
     139           0 :                                 continue;
     140             : 
     141             :                         /*
     142             :                          * Never return an empty share name or the attribute
     143             :                          * server if it wasn't what was requested.
     144             :                          */
     145           0 :                         if (*srv->share_name == '\0' ||
     146           0 :                             strcmp(srv->share_name, "*IPC$") == 0)
     147           0 :                                 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           0 :                         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           0 :                                 status = cli_tdis(srv->server->cli);
     162           0 :                                 if (!NT_STATUS_IS_OK(status)) {
     163             :                                         /* Sigh. Couldn't disconnect. */
     164           0 :                                         cli_shutdown(srv->server->cli);
     165           0 :                                         srv->server->cli = NULL;
     166           0 :                                         smbc_getFunctionRemoveCachedServer(context)(context, srv->server);
     167           0 :                                         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           0 :                                 SAFE_FREE(srv->share_name);
     176           0 :                                 srv->share_name = SMB_STRDUP(share);
     177           0 :                                 if (!srv->share_name) {
     178             :                                         /* Out of memory. */
     179           0 :                                         cli_shutdown(srv->server->cli);
     180           0 :                                         srv->server->cli = NULL;
     181           0 :                                         smbc_getFunctionRemoveCachedServer(context)(context, srv->server);
     182           0 :                                         continue;
     183             :                                 }
     184             : 
     185           0 :                                 return srv->server;
     186             :                         }
     187             :                 }
     188             :         }
     189             : 
     190           0 :         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
     200           0 : SMBC_remove_cached_server(SMBCCTX * context,
     201             :                           SMBCSRV * server)
     202             : {
     203           0 :         struct smbc_server_cache * srv = NULL;
     204             : 
     205           0 :         for (srv = context->internal->server_cache; srv; srv = srv->next) {
     206           0 :                 if (server == srv->server) {
     207             : 
     208             :                         /* remove this sucker */
     209           0 :                         DLIST_REMOVE(context->internal->server_cache, srv);
     210           0 :                         SAFE_FREE(srv->server_name);
     211           0 :                         SAFE_FREE(srv->share_name);
     212           0 :                         SAFE_FREE(srv->workgroup);
     213           0 :                         SAFE_FREE(srv->username);
     214           0 :                         SAFE_FREE(srv);
     215           0 :                         return 0;
     216             :                 }
     217             :         }
     218             :         /* server not found */
     219           0 :         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
     228           0 : SMBC_purge_cached_servers(SMBCCTX * context)
     229             : {
     230             :         struct smbc_server_cache * srv;
     231             :         struct smbc_server_cache * next;
     232           0 :         int could_not_purge_all = 0;
     233             : 
     234           0 :         for (srv = context->internal->server_cache,
     235           0 :                      next = (srv ? srv->next :NULL);
     236           0 :              srv;
     237           0 :              srv = next,
     238           0 :                      next = (srv ? srv->next : NULL)) {
     239             : 
     240           0 :                 if (SMBC_remove_unused_server(context, srv->server)) {
     241             :                         /* could not be removed */
     242           0 :                         could_not_purge_all = 1;
     243             :                 }
     244             :         }
     245           0 :         return could_not_purge_all;
     246             : }