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                       int max_connections, 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         /*
 182          * Enforce the max connections parameter.
 183          */
 184
 185         if (max_connections > 0) {
 186                 int curr_connections;
 187
 188                 curr_connections = count_current_connections( lp_servicename(SNUM(conn)), True );
 189
 190                 if (curr_connections >= max_connections) {
 191                         DEBUG(1,("claim_connection: Max connections (%d) exceeded for %s\n",
 192                                 max_connections, name ));
 193                         return False;
 194                 }
 195         }
 196
 197         DEBUG(5,("claiming %s %d\n",name,max_connections));
 198
 199         make_conn_key(conn, name, &kbuf, &key);
 200
 201         /* fill in the crec */
 202         ZERO_STRUCT(crec);
 203         crec.magic = 0x280267;
 204         crec.pid = procid_self();
 205         crec.cnum = conn?conn->cnum:-1;
 206         if (conn) {
 207                 crec.uid = conn->uid;
 208                 crec.gid = conn->gid;
 209                 safe_strcpy(crec.servicename,
 210                             lp_servicename(SNUM(conn)),sizeof(crec.servicename)-1);
 211         }
 212         crec.start = time(NULL);
 213         crec.bcast_msg_flags = msg_flags;
 214
 215         safe_strcpy(crec.machine,get_remote_machine_name(),sizeof(crec.machine)-1);
 216         safe_strcpy(crec.addr,conn?conn->client_address:client_addr(),sizeof(crec.addr)-1);
 217
 218         dbuf.dptr = (uint8 *)&crec;
 219         dbuf.dsize = sizeof(crec);
 220
 221         if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
 222                 DEBUG(0,("claim_connection: tdb_store failed with error %s.\n",
 223                         tdb_errorstr(tdb) ));
 224                 return False;
 225         }
 226
 227         return True;
 228 }
 229
 230 BOOL register_message_flags(BOOL doreg, uint32 msg_flags)
 231 {
 232         struct connections_key key;
 233         struct connections_data *pcrec;
 234         TDB_DATA kbuf, dbuf;
 235         TDB_CONTEXT *tdb = conn_tdb_ctx(True);
 236
 237         if (!tdb)
 238                 return False;
 239
 240         DEBUG(10,("register_message_flags: %s flags 0x%x\n",
 241                 doreg ? "adding" : "removing",
 242                 (unsigned int)msg_flags ));
 243
 244         make_conn_key(NULL, "", &kbuf, &key);
 245
 246         dbuf = tdb_fetch(tdb, kbuf);
 247         if (!dbuf.dptr) {
 248                 DEBUG(0,("register_message_flags: tdb_fetch failed: %s\n",
 249                         tdb_errorstr(tdb)));
 250                 return False;
 251         }
 252
 253         pcrec = (struct connections_data *)dbuf.dptr;
 254         if (doreg)
 255                 pcrec->bcast_msg_flags |= msg_flags;
 256         else
 257                 pcrec->bcast_msg_flags &= ~msg_flags;
 258
 259         if (tdb_store(tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
 260                 DEBUG(0,("register_message_flags: tdb_store failed: %s.\n",
 261                         tdb_errorstr(tdb) ));
 262                 SAFE_FREE(dbuf.dptr);
 263                 return False;
 264         }
 265
 266         DEBUG(10,("register_message_flags: new flags 0x%x\n",
 267                 (unsigned int)pcrec->bcast_msg_flags ));
 268
 269         SAFE_FREE(dbuf.dptr);
 270         return True;
 271 }
 272
 273 /*********************************************************************
 274 *********************************************************************/
 275
 276 static TDB_DATA* make_pipe_rec_key( struct pipe_open_rec *prec )
 277 {
 278         TDB_DATA *kbuf = NULL;
 279         fstring key_string;
 280
 281         if ( !prec )
 282                 return NULL;
 283
 284         if ( (kbuf = TALLOC_P(prec, TDB_DATA)) == NULL ) {
 285                 return NULL;
 286         }
 287
 288         snprintf( key_string, sizeof(key_string), "%s/%d/%d",
 289                 prec->name, procid_to_pid(&prec->pid), prec->pnum );
 290
 291         *kbuf = string_term_tdb_data(talloc_strdup(prec, key_string));
 292         if (kbuf->dptr == NULL )
 293                 return NULL;
 294
 295         return kbuf;
 296 }
 297
 298 /*********************************************************************
 299 *********************************************************************/
 300
 301 static void fill_pipe_open_rec( struct pipe_open_rec *prec, smb_np_struct *p )
 302 {
 303         prec->pid = pid_to_procid(sys_getpid());
 304         prec->pnum = p->pnum;
 305         prec->uid = geteuid();
 306         fstrcpy( prec->name, p->name );
 307
 308         return;
 309 }
 310
 311 /*********************************************************************
 312 *********************************************************************/
 313
 314 BOOL store_pipe_opendb( smb_np_struct *p )
 315 {
 316         struct pipe_open_rec *prec;
 317         TDB_DATA *key;
 318         TDB_DATA data;
 319         TDB_CONTEXT *pipe_tdb;
 320         BOOL ret = False;
 321
 322         if ( (prec = TALLOC_P( NULL, struct pipe_open_rec)) == NULL ) {
 323                 DEBUG(0,("store_pipe_opendb: talloc failed!\n"));
 324                 return False;
 325         }
 326
 327         fill_pipe_open_rec( prec, p );
 328         if ( (key = make_pipe_rec_key( prec )) == NULL ) {
 329                 goto done;
 330         }
 331
 332         data.dptr = (uint8 *)prec;
 333         data.dsize = sizeof(struct pipe_open_rec);
 334
 335         if ( (pipe_tdb = conn_tdb_ctx(True) ) == NULL ) {
 336                 goto done;
 337         }
 338
 339         ret = (tdb_store( pipe_tdb, *key, data, TDB_REPLACE ) != -1);
 340
 341 done:
 342         TALLOC_FREE( prec );
 343         return ret;
 344 }
 345
 346 /*********************************************************************
 347 *********************************************************************/
 348
 349 BOOL delete_pipe_opendb( smb_np_struct *p )
 350 {
 351         struct pipe_open_rec *prec;
 352         TDB_DATA *key;
 353         TDB_CONTEXT *pipe_tdb;
 354         BOOL ret = False;
 355
 356         if ( (prec = TALLOC_P( NULL, struct pipe_open_rec)) == NULL ) {
 357                 DEBUG(0,("store_pipe_opendb: talloc failed!\n"));
 358                 return False;
 359         }
 360
 361         fill_pipe_open_rec( prec, p );
 362         if ( (key = make_pipe_rec_key( prec )) == NULL ) {
 363                 goto done;
 364         }
 365
 366         if ( (pipe_tdb = conn_tdb_ctx(True) ) == NULL ) {
 367                 goto done;
 368         }
 369
 370         ret = (tdb_delete( pipe_tdb, *key ) != -1 );
 371
 372 done:
 373         TALLOC_FREE( prec );
 374         return ret;
 375 }