source/smbd/connection.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    connection claim routines
   4    Copyright (C) Andrew Tridgell 1998
   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 static void make_conn_key(connection_struct *conn, const char *name, TDB_DATA *pkbuf, struct connections_key *pkey)
  24 {
  25         ZERO_STRUCTP(pkey);
  26         pkey->pid = procid_self();
  27         pkey->cnum = conn?conn->cnum:-1;
  28         fstrcpy(pkey->name, name);
  29 #ifdef DEVELOPER
  30         /* valgrind fixer... */
  31         {
  32                 size_t sl = strlen(pkey->name);
  33                 if (sizeof(fstring)-sl)
  34                         memset(&pkey->name[sl], '\0', sizeof(fstring)-sl);
  35         }
  36 #endif
  37
  38         pkbuf->dptr = (uint8 *)pkey;
  39         pkbuf->dsize = sizeof(*pkey);
  40 }
  41
  42 /****************************************************************************
  43  Delete a connection record.
  44 ****************************************************************************/
  45
  46 BOOL yield_connection(connection_struct *conn, const char *name)
  47 {
  48         struct connections_key key;
  49         TDB_DATA kbuf;
  50         TDB_CONTEXT *tdb = conn_tdb_ctx(True);
  51
  52         if (!tdb)
  53                 return False;
  54
  55         DEBUG(3,("Yielding connection to %s\n",name));
  56
  57         make_conn_key(conn, name, &kbuf, &key);
  58
  59         if (tdb_delete(tdb, kbuf) != 0) {
  60                 int dbg_lvl = (!conn && (tdb_error(tdb) == TDB_ERR_NOEXIST)) ? 3 : 0;
  61                 DEBUG(dbg_lvl,("yield_connection: tdb_delete for name %s failed with error %s.\n",
  62                         name, tdb_errorstr(tdb) ));
  63                 return (False);
  64         }
  65
  66         return(True);
  67 }
  68
  69 struct count_stat {
  70         pid_t mypid;
  71         int curr_connections;
  72         const char *name;
  73         BOOL Clear;
  74 };
  75
  76 /****************************************************************************
  77  Count the entries belonging to a service in the connection db.
  78 ****************************************************************************/
  79
  80 static int count_fn( TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *udp)
  81 {
  82         struct connections_data crec;
  83         struct count_stat *cs = (struct count_stat *)udp;
  84
  85         if (dbuf.dsize != sizeof(crec)) {
  86                 return 0;
  87         }
  88
  89         memcpy(&crec, dbuf.dptr, sizeof(crec));
  90
  91         if (crec.cnum == -1) {
  92                 return 0;
  93         }
  94
  95         /* If the pid was not found delete the entry from connections.tdb */
  96
  97         if (cs->Clear && !process_exists(crec.pid) && (errno == ESRCH)) {
  98                 DEBUG(2,("pid %s doesn't exist - deleting connections %d [%s]\n",
  99                         procid_str_static(&crec.pid), crec.cnum, crec.servicename));
 100                 if (tdb_delete(the_tdb, kbuf) != 0)
 101                         DEBUG(0,("count_fn: tdb_delete failed with error %s\n", tdb_errorstr(the_tdb) ));
 102                 return 0;
 103         }
 104
 105         if (cs->name) {
 106                 /* We are counting all the connections to a given share. */
 107                 if (strequal(crec.servicename, cs->name)) {
 108                         cs->curr_connections++;
 109                 }
 110         } else {
 111                 /* We are counting all the connections. Static registrations
 112                  * like the lpq backgroud process and the smbd daemon process
 113                  * have a cnum of -1, so won't be counted here.
 114                  */
 115                 cs->curr_connections++;
 116         }
 117
 118         return 0;
 119 }
 120
 121 /****************************************************************************
 122  Claim an entry in the connections database.
 123 ****************************************************************************/
 124
 125 int count_current_connections( const char *sharename, BOOL clear  )
 126 {
 127         struct count_stat cs;
 128         TDB_CONTEXT *tdb = conn_tdb_ctx(True);
 129
 130         cs.mypid = sys_getpid();
 131         cs.curr_connections = 0;
 132         cs.name = sharename;
 133         cs.Clear = clear;
 134
 135         /*
 136          * This has a race condition, but locking the chain before hand is worse
 137          * as it leads to deadlock.
 138          */
 139
 140         if (tdb_traverse(tdb, count_fn, &cs) == -1) {
 141                 DEBUG(0,("count_current_connections: traverse of connections.tdb failed with error %s\n",
 142                         tdb_errorstr(tdb) ));
 143                 DEBUGADD(0, ("count_current_connections: connection count of %d might not be accurate",
 144                             cs.curr_connections));
 145         }
 146
 147         /* If the traverse failed part-way through, we at least return
 148          * as many connections as we had already counted. If it failed
 149          * right at the start, we will return 0, which is about all we
 150          * can do anywway.
 151          */
 152
 153         return cs.curr_connections;
 154 }
 155
 156 /****************************************************************************
 157  Count the number of connections open across all shares.
 158 ****************************************************************************/
 159
 160 int count_all_current_connections(void)
 161 {
 162         return count_current_connections(NULL, True /* clear stale entries */);
 163 }
 164
 165 /****************************************************************************
 166  Claim an entry in the connections database.
 167 ****************************************************************************/
 168
 169 BOOL claim_connection(connection_struct *conn, const char *name,
 170                       uint32 msg_flags)
 171 {
 172         struct connections_key key;
 173         struct connections_data crec;
 174         TDB_DATA kbuf, dbuf;
 175         TDB_CONTEXT *tdb = conn_tdb_ctx(True);
 176
 177         if (!tdb) {
 178                 return False;
 179         }
 180
 181         DEBUG(5,("claiming %s\n",name));
 182
 183         make_conn_key(conn, name, &kbuf, &key);
 184
 185         /* fill in the crec */
 186         ZERO_STRUCT(crec);
 187         crec.magic = 0x280267;
 188         crec.pid = procid_self();
 189         crec.cnum = conn?conn->cnum:-1;
 190         if (conn) {
 191                 crec.uid = conn->uid;
 192                 crec.gid = conn->gid;
 193                 safe_strcpy(crec.servicename,
 194                             lp_servicename(SNUM(conn)),sizeof(crec.servicename)-1);
 195         }
 196         crec.start = time(NULL);
 197         crec.bcast_msg_flags = msg_flags;
 198
 199         safe_strcpy(crec.machine,get_remote_machine_name(),sizeof(crec.machine)-1);
 200         safe_strcpy(crec.addr,conn?conn->client_address:client_addr(),sizeof(crec.addr)-1);
 201
 202         dbuf.dptr = (uint8 *)&crec;
 203         dbuf.dsize = sizeof(crec);
 204
 205         if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
 206                 DEBUG(0,("claim_connection: tdb_store failed with error %s.\n",
 207                         tdb_errorstr(tdb) ));
 208                 return False;
 209         }
 210
 211         return True;
 212 }
 213
 214 BOOL register_message_flags(BOOL doreg, uint32 msg_flags)
 215 {
 216         struct connections_key key;
 217         struct connections_data *pcrec;
 218         TDB_DATA kbuf, dbuf;
 219         TDB_CONTEXT *tdb = conn_tdb_ctx(True);
 220
 221         if (!tdb)
 222                 return False;
 223
 224         DEBUG(10,("register_message_flags: %s flags 0x%x\n",
 225                 doreg ? "adding" : "removing",
 226                 (unsigned int)msg_flags ));
 227
 228         make_conn_key(NULL, "", &kbuf, &key);
 229
 230         dbuf = tdb_fetch(tdb, kbuf);
 231         if (!dbuf.dptr) {
 232                 DEBUG(0,("register_message_flags: tdb_fetch failed: %s\n",
 233                         tdb_errorstr(tdb)));
 234                 return False;
 235         }
 236
 237         pcrec = (struct connections_data *)dbuf.dptr;
 238         if (doreg)
 239                 pcrec->bcast_msg_flags |= msg_flags;
 240         else
 241                 pcrec->bcast_msg_flags &= ~msg_flags;
 242
 243         if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
 244                 DEBUG(0,("register_message_flags: tdb_store failed: %s.\n",
 245                         tdb_errorstr(tdb) ));
 246                 SAFE_FREE(dbuf.dptr);
 247                 return False;
 248         }
 249
 250         DEBUG(10,("register_message_flags: new flags 0x%x\n",
 251                 (unsigned int)pcrec->bcast_msg_flags ));
 252
 253         SAFE_FREE(dbuf.dptr);
 254         return True;
 255 }
 256
 257 /*********************************************************************
 258 *********************************************************************/
 259
 260 static TDB_DATA* make_pipe_rec_key( struct pipe_open_rec *prec )
 261 {
 262         TDB_DATA *kbuf = NULL;
 263         fstring key_string;
 264
 265         if ( !prec )
 266                 return NULL;
 267
 268         if ( (kbuf = TALLOC_P(prec, TDB_DATA)) == NULL ) {
 269                 return NULL;
 270         }
 271
 272         snprintf( key_string, sizeof(key_string), "%s/%d/%d",
 273                 prec->name, procid_to_pid(&prec->pid), prec->pnum );
 274
 275         *kbuf = string_term_tdb_data(talloc_strdup(prec, key_string));
 276         if (kbuf->dptr == NULL )
 277                 return NULL;
 278
 279         return kbuf;
 280 }
 281
 282 /*********************************************************************
 283 *********************************************************************/
 284
 285 static void fill_pipe_open_rec( struct pipe_open_rec *prec, smb_np_struct *p )
 286 {
 287         prec->pid = pid_to_procid(sys_getpid());
 288         prec->pnum = p->pnum;
 289         prec->uid = geteuid();
 290         fstrcpy( prec->name, p->name );
 291
 292         return;
 293 }
 294
 295 /*********************************************************************
 296 *********************************************************************/
 297
 298 BOOL store_pipe_opendb( smb_np_struct *p )
 299 {
 300         struct pipe_open_rec *prec;
 301         TDB_DATA *key;
 302         TDB_DATA data;
 303         TDB_CONTEXT *pipe_tdb;
 304         BOOL ret = False;
 305
 306         if ( (prec = TALLOC_P( NULL, struct pipe_open_rec)) == NULL ) {
 307                 DEBUG(0,("store_pipe_opendb: talloc failed!\n"));
 308                 return False;
 309         }
 310
 311         fill_pipe_open_rec( prec, p );
 312         if ( (key = make_pipe_rec_key( prec )) == NULL ) {
 313                 goto done;
 314         }
 315
 316         data.dptr = (uint8 *)prec;
 317         data.dsize = sizeof(struct pipe_open_rec);
 318
 319         if ( (pipe_tdb = conn_tdb_ctx(True) ) == NULL ) {
 320                 goto done;
 321         }
 322
 323         ret = (tdb_store( pipe_tdb, *key, data, TDB_REPLACE ) != -1);
 324
 325 done:
 326         TALLOC_FREE( prec );
 327         return ret;
 328 }
 329
 330 /*********************************************************************
 331 *********************************************************************/
 332
 333 BOOL delete_pipe_opendb( smb_np_struct *p )
 334 {
 335         struct pipe_open_rec *prec;
 336         TDB_DATA *key;
 337         TDB_CONTEXT *pipe_tdb;
 338         BOOL ret = False;
 339
 340         if ( (prec = TALLOC_P( NULL, struct pipe_open_rec)) == NULL ) {
 341                 DEBUG(0,("store_pipe_opendb: talloc failed!\n"));
 342                 return False;
 343         }
 344
 345         fill_pipe_open_rec( prec, p );
 346         if ( (key = make_pipe_rec_key( prec )) == NULL ) {
 347                 goto done;
 348         }
 349
 350         if ( (pipe_tdb = conn_tdb_ctx(True) ) == NULL ) {
 351                 goto done;
 352         }
 353
 354         ret = (tdb_delete( pipe_tdb, *key ) != -1 );
 355
 356 done:
 357         TALLOC_FREE( prec );
 358         return ret;
 359 }