Line data    Source code

       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             :    Manage smbsrv_tcon structures
       4             :    Copyright (C) Andrew Tridgell 1998
       5             :    Copyright (C) Alexander Bokovoy 2002
       6             :    Copyright (C) Stefan Metzmacher 2005-2006
       7             :    
       8             :    This program is free software; you can redistribute it and/or modify
       9             :    it under the terms of the GNU General Public License as published by
      10             :    the Free Software Foundation; either version 3 of the License, or
      11             :    (at your option) any later version.
      12             :    
      13             :    This program is distributed in the hope that it will be useful,
      14             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16             :    GNU General Public License for more details.
      17             :    
      18             :    You should have received a copy of the GNU General Public License
      19             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      20             : */
      21             : 
      22             : #include "includes.h"
      23             : #include "smb_server/smb_server.h"
      24             : #include "samba/service_stream.h"
      25             : #include "lib/tsocket/tsocket.h"
      26             : #include "ntvfs/ntvfs.h"
      27             : #include "lib/util/idtree_random.h"
      28             : 
      29             : /****************************************************************************
      30             : init the tcon structures
      31             : ****************************************************************************/
      32        4400 : static NTSTATUS smbsrv_init_tcons(struct smbsrv_tcons_context *tcons_ctx, TALLOC_CTX *mem_ctx, uint32_t limit)
      33             : {
      34             :         /* 
      35             :          * the idr_* functions take 'int' as limit,
      36             :          * and only work with a max limit 0x00FFFFFF
      37             :          */
      38        4400 :         limit &= 0x00FFFFFF;
      39             : 
      40        4400 :         tcons_ctx->idtree_tid        = idr_init(mem_ctx);
      41        4400 :         NT_STATUS_HAVE_NO_MEMORY(tcons_ctx->idtree_tid);
      42        4400 :         tcons_ctx->idtree_limit      = limit;
      43        4400 :         tcons_ctx->list              = NULL;
      44             : 
      45        4400 :         return NT_STATUS_OK;
      46             : }
      47             : 
      48        2254 : NTSTATUS smbsrv_smb_init_tcons(struct smbsrv_connection *smb_conn)
      49             : {
      50        2254 :         return smbsrv_init_tcons(&smb_conn->smb_tcons, smb_conn, UINT16_MAX);
      51             : }
      52             : 
      53        2146 : NTSTATUS smbsrv_smb2_init_tcons(struct smbsrv_session *smb_sess)
      54             : {
      55        2146 :         return smbsrv_init_tcons(&smb_sess->smb2_tcons, smb_sess, UINT32_MAX);
      56             : }
      57             : 
      58             : /****************************************************************************
      59             : find a tcon given a tid for SMB
      60             : ****************************************************************************/
      61      831313 : static struct smbsrv_tcon *smbsrv_tcon_find(struct smbsrv_tcons_context *tcons_ctx,
      62             :                                             uint32_t tid, struct timeval request_time)
      63             : {
      64             :         void *p;
      65             :         struct smbsrv_tcon *tcon;
      66             : 
      67      831313 :         if (tid == 0) return NULL;
      68             : 
      69      824677 :         if (tid > tcons_ctx->idtree_limit) return NULL;
      70             : 
      71      824677 :         p = idr_find(tcons_ctx->idtree_tid, tid);
      72      824677 :         if (!p) return NULL;
      73             : 
      74      824574 :         tcon = talloc_get_type(p, struct smbsrv_tcon);
      75      824574 :         if (!tcon) return NULL;
      76             : 
      77      824574 :         tcon->statistics.last_request_time = request_time;
      78             : 
      79      824574 :         return tcon;
      80             : }
      81             : 
      82      423389 : struct smbsrv_tcon *smbsrv_smb_tcon_find(struct smbsrv_connection *smb_conn,
      83             :                                          uint32_t tid, struct timeval request_time)
      84             : {
      85      423389 :         return smbsrv_tcon_find(&smb_conn->smb_tcons, tid, request_time);
      86             : }
      87             : 
      88      411052 : struct smbsrv_tcon *smbsrv_smb2_tcon_find(struct smbsrv_session *smb_sess,
      89             :                                           uint32_t tid, struct timeval request_time)
      90             : {
      91      411052 :         if (!smb_sess) return NULL;
      92      407924 :         return smbsrv_tcon_find(&smb_sess->smb2_tcons, tid, request_time);
      93             : }
      94             : 
      95             : /*
      96             :   destroy a connection structure
      97             : */
      98        2640 : static int smbsrv_tcon_destructor(struct smbsrv_tcon *tcon)
      99             : {
     100             :         struct smbsrv_tcons_context *tcons_ctx;
     101             :         struct tsocket_address *client_addr;
     102             : 
     103        2640 :         client_addr = tcon->smb_conn->connection->remote_address;
     104             : 
     105        2640 :         DEBUG(3,("%s closed connection to service %s\n",
     106             :                  tsocket_address_string(client_addr, tcon),
     107             :                  tcon->share_name));
     108             : 
     109             :         /* tell the ntvfs backend that we are disconnecting */
     110        2640 :         if (tcon->ntvfs) {
     111        2640 :                 ntvfs_disconnect(tcon->ntvfs);
     112        2640 :                 tcon->ntvfs = NULL;
     113             :         }
     114             : 
     115        2640 :         if (tcon->smb2.session) {
     116        1663 :                 tcons_ctx = &tcon->smb2.session->smb2_tcons;
     117             :         } else {
     118         977 :                 tcons_ctx = &tcon->smb_conn->smb_tcons;
     119             :         }
     120             : 
     121        2640 :         idr_remove(tcons_ctx->idtree_tid, tcon->tid);
     122        2640 :         DLIST_REMOVE(tcons_ctx->list, tcon);
     123        2640 :         return 0;
     124             : }
     125             : 
     126             : /*
     127             :   find first available connection slot
     128             : */
     129        2640 : static struct smbsrv_tcon *smbsrv_tcon_new(struct smbsrv_connection *smb_conn,
     130             :                                            struct smbsrv_session *smb_sess,
     131             :                                            const char *share_name)
     132             : {
     133             :         TALLOC_CTX *mem_ctx;
     134             :         struct smbsrv_tcons_context *tcons_ctx;
     135             :         uint32_t handle_uint_max;
     136             :         struct smbsrv_tcon *tcon;
     137             :         NTSTATUS status;
     138             :         int i;
     139             : 
     140        2640 :         if (smb_sess) {
     141        1663 :                 mem_ctx = smb_sess;
     142        1663 :                 tcons_ctx = &smb_sess->smb2_tcons;
     143        1663 :                 handle_uint_max = UINT32_MAX;
     144             :         } else {
     145         977 :                 mem_ctx = smb_conn;
     146         977 :                 tcons_ctx = &smb_conn->smb_tcons;
     147         977 :                 handle_uint_max = UINT16_MAX;
     148             :         }
     149             : 
     150        2640 :         tcon = talloc_zero(mem_ctx, struct smbsrv_tcon);
     151        2640 :         if (!tcon) return NULL;
     152        2640 :         tcon->smb_conn               = smb_conn;
     153        2640 :         tcon->smb2.session   = smb_sess;
     154        2640 :         tcon->share_name     = talloc_strdup(tcon, share_name);
     155        2640 :         if (!tcon->share_name) goto failed;
     156             : 
     157             :         /*
     158             :          * the use -1 here, because we don't want to give away the wildcard
     159             :          * fnum used in SMBflush
     160             :          */
     161        2640 :         status = smbsrv_init_handles(tcon, handle_uint_max - 1);
     162        2640 :         if (!NT_STATUS_IS_OK(status)) {
     163           0 :                 DEBUG(1,("ERROR! failed to init handles: %s\n", nt_errstr(status)));
     164           0 :                 goto failed;
     165             :         }
     166             : 
     167        2640 :         i = idr_get_new_random(
     168        2640 :                 tcons_ctx->idtree_tid, tcon, 1, tcons_ctx->idtree_limit);
     169        2640 :         if (i == -1) {
     170           0 :                 DEBUG(1,("ERROR! Out of connection structures\n"));
     171           0 :                 goto failed;
     172             :         }
     173        2640 :         tcon->tid = i;
     174             : 
     175        2640 :         DLIST_ADD(tcons_ctx->list, tcon);
     176        2640 :         talloc_set_destructor(tcon, smbsrv_tcon_destructor);
     177             : 
     178             :         /* now fill in some statistics */
     179        2640 :         tcon->statistics.connect_time = timeval_current();
     180             : 
     181        2640 :         return tcon;
     182             : 
     183           0 : failed:
     184           0 :         talloc_free(tcon);
     185           0 :         return NULL;
     186             : }
     187             : 
     188         977 : struct smbsrv_tcon *smbsrv_smb_tcon_new(struct smbsrv_connection *smb_conn, const char *share_name)
     189             : {
     190         977 :         return smbsrv_tcon_new(smb_conn, NULL, share_name);
     191             : }
     192             : 
     193        1663 : struct smbsrv_tcon *smbsrv_smb2_tcon_new(struct smbsrv_session *smb_sess, const char *share_name)
     194             : {
     195        1663 :         return smbsrv_tcon_new(smb_sess->smb_conn, smb_sess, share_name);
     196             : }