source3/smbd/files.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Files[] structure handling
   5    Copyright (C) Andrew Tridgell 1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26 static int real_max_open_files;
  27
  28 #define VALID_FNUM(fnum)   (((fnum) >= 0) && ((fnum) < real_max_open_files))
  29
  30 #define FILE_HANDLE_OFFSET 0x1000
  31
  32 static struct bitmap *file_bmap;
  33
  34 static files_struct *Files;
  35
  36 /* a fsp to use when chaining */
  37 static files_struct *chain_fsp = NULL;
  38 /* a fsp to use to save when breaking an oplock. */
  39 static files_struct *oplock_save_chain_fsp = NULL;
  40
  41 static int files_used;
  42
  43 /****************************************************************************
  44   find first available file slot
  45 ****************************************************************************/
  46 files_struct *file_new(void )
  47 {
  48         int i;
  49         static int first_file;
  50         files_struct *fsp, *next;
  51
  52         /* we want to give out file handles differently on each new
  53            connection because of a common bug in MS clients where they try to
  54            reuse a file descriptor from an earlier smb connection. This code
  55            increases the chance that the errant client will get an error rather
  56            than causing corruption */
  57         if (first_file == 0) {
  58                 first_file = (getpid() ^ (int)time(NULL)) % real_max_open_files;
  59         }
  60
  61         i = bitmap_find(file_bmap, first_file);
  62         if (i == -1) {
  63                 /*
  64                  * Before we give up, go through the open files
  65                  * and see if there are any files opened with a
  66                  * batch oplock. If so break the oplock and then
  67                  * re-use that entry (if it becomes closed).
  68                  * This may help as NT/95 clients tend to keep
  69                  * files batch oplocked for quite a long time
  70                  * after they have finished with them.
  71                  */
  72                 for (fsp=Files;fsp;fsp=next) {
  73                         next=fsp->next;
  74                         if (attempt_close_oplocked_file(fsp)) {
  75                                 return file_new();
  76                         }
  77                 }
  78
  79                 DEBUG(0,("ERROR! Out of file structures\n"));
  80                 return NULL;
  81         }
  82
  83         fsp = (files_struct *)malloc(sizeof(*fsp));
  84         if (!fsp) return NULL;
  85
  86         ZERO_STRUCTP(fsp);
  87         fsp->fd = -1;
  88
  89         first_file = (i+1) % real_max_open_files;
  90
  91         bitmap_set(file_bmap, i);
  92         files_used++;
  93
  94         fsp->fnum = i + FILE_HANDLE_OFFSET;
  95         string_set(&fsp->fsp_name,"");
  96
  97         DLIST_ADD(Files, fsp);
  98
  99         DEBUG(5,("allocated file structure %d, fnum = %d (%d used)\n",
 100                  i, fsp->fnum, files_used));
 101
 102         chain_fsp = fsp;
 103
 104         return fsp;
 105 }
 106
 107
 108 /****************************************************************************
 109 close all open files for a connection
 110 ****************************************************************************/
 111 void file_close_conn(connection_struct *conn)
 112 {
 113         files_struct *fsp, *next;
 114
 115         for (fsp=Files;fsp;fsp=next) {
 116                 next = fsp->next;
 117                 if (fsp->conn == conn && fsp->open) {
 118                         close_file(fsp,False);
 119                 }
 120         }
 121 }
 122
 123 /****************************************************************************
 124 initialise file structures
 125 ****************************************************************************/
 126
 127 #define MAX_OPEN_FUDGEFACTOR 10
 128
 129 void file_init(void)
 130 {
 131         int request_max_open_files = lp_max_open_files();
 132         int real_lim;
 133
 134         /*
 135          * Set the max_open files to be the requested
 136          * max plus a fudgefactor to allow for the extra
 137          * fd's we need such as log files etc...
 138          */
 139         real_lim = set_maxfiles(request_max_open_files + MAX_OPEN_FUDGEFACTOR);
 140
 141         real_max_open_files = real_lim - MAX_OPEN_FUDGEFACTOR;
 142
 143         if(real_max_open_files != request_max_open_files) {
 144                 DEBUG(1,("file_init: Information only: requested %d \
 145 open files, %d are available.\n", request_max_open_files, real_max_open_files));
 146         }
 147
 148         file_bmap = bitmap_allocate(real_max_open_files);
 149
 150         if (!file_bmap) {
 151                 exit_server("out of memory in file_init");
 152         }
 153
 154         /*
 155          * Ensure that pipe_handle_oppset is set correctly.
 156          */
 157         set_pipe_handle_offset(real_max_open_files);
 158 }
 159
 160
 161 /****************************************************************************
 162 close files open by a specified vuid
 163 ****************************************************************************/
 164 void file_close_user(int vuid)
 165 {
 166         files_struct *fsp, *next;
 167
 168         for (fsp=Files;fsp;fsp=next) {
 169                 next=fsp->next;
 170                 if ((fsp->vuid == vuid) && fsp->open) {
 171                         close_file(fsp,False);
 172                 }
 173         }
 174 }
 175
 176
 177 /****************************************************************************
 178  Find a fsp given a device, inode and timevalue
 179  If this is from a kernel oplock break request then tval may be NULL.
 180 ****************************************************************************/
 181
 182 files_struct *file_find_dit(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
 183 {
 184         int count=0;
 185         files_struct *fsp;
 186
 187         for (fsp=Files;fsp;fsp=fsp->next,count++) {
 188                 if (fsp->open &&
 189                         fsp->fd != -1 &&
 190                     fsp->dev == dev &&
 191                     fsp->inode == inode &&
 192                     (tval ? (fsp->open_time.tv_sec == tval->tv_sec) : True ) &&
 193                     (tval ? (fsp->open_time.tv_usec == tval->tv_usec) : True )) {
 194                         if (count > 10) {
 195                                 DLIST_PROMOTE(Files, fsp);
 196                         }
 197                         return fsp;
 198                 }
 199         }
 200
 201         return NULL;
 202 }
 203
 204 /****************************************************************************
 205  Find the first fsp given a device and inode.
 206 ****************************************************************************/
 207
 208 files_struct *file_find_di_first(SMB_DEV_T dev, SMB_INO_T inode)
 209 {
 210     files_struct *fsp;
 211
 212     for (fsp=Files;fsp;fsp=fsp->next) {
 213         if (fsp->open &&
 214             fsp->fd != -1 &&
 215             fsp->dev == dev &&
 216             fsp->inode == inode )
 217             return fsp;
 218     }
 219
 220     return NULL;
 221 }
 222
 223 /****************************************************************************
 224  Find the next fsp having the same device and inode.
 225 ****************************************************************************/
 226
 227 files_struct *file_find_di_next(files_struct *start_fsp)
 228 {
 229     files_struct *fsp;
 230
 231     for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
 232         if (fsp->open &&
 233             fsp->fd != -1 &&
 234             fsp->dev == start_fsp->dev &&
 235             fsp->inode == start_fsp->inode )
 236             return fsp;
 237     }
 238
 239     return NULL;
 240 }
 241
 242 /****************************************************************************
 243 find a fsp that is open for printing
 244 ****************************************************************************/
 245 files_struct *file_find_print(void)
 246 {
 247         files_struct *fsp;
 248
 249         for (fsp=Files;fsp;fsp=fsp->next) {
 250                 if (fsp->open && fsp->print_file) return fsp;
 251         }
 252
 253         return NULL;
 254 }
 255
 256
 257 /****************************************************************************
 258 sync open files on a connection
 259 ****************************************************************************/
 260 void file_sync_all(connection_struct *conn)
 261 {
 262         files_struct *fsp, *next;
 263
 264         for (fsp=Files;fsp;fsp=next) {
 265                 next=fsp->next;
 266                 if (fsp->open && (conn == fsp->conn) && (fsp->fd != -1)) {
 267                         conn->vfs_ops.fsync(fsp->fd);
 268                 }
 269         }
 270 }
 271
 272
 273 /****************************************************************************
 274 free up a fsp
 275 ****************************************************************************/
 276 void file_free(files_struct *fsp)
 277 {
 278         DLIST_REMOVE(Files, fsp);
 279
 280         string_free(&fsp->fsp_name);
 281
 282         bitmap_clear(file_bmap, fsp->fnum - FILE_HANDLE_OFFSET);
 283         files_used--;
 284
 285         DEBUG(5,("freed files structure %d (%d used)\n",
 286                  fsp->fnum, files_used));
 287
 288         /* this is paranoia, just in case someone tries to reuse the
 289            information */
 290         ZERO_STRUCTP(fsp);
 291
 292         if (fsp == chain_fsp) chain_fsp = NULL;
 293
 294         free(fsp);
 295 }
 296
 297
 298 /****************************************************************************
 299 get a fsp from a packet given the offset of a 16 bit fnum
 300 ****************************************************************************/
 301 files_struct *file_fsp(char *buf, int where)
 302 {
 303         int fnum, count=0;
 304         files_struct *fsp;
 305
 306         if (chain_fsp) return chain_fsp;
 307
 308         fnum = SVAL(buf, where);
 309
 310         for (fsp=Files;fsp;fsp=fsp->next, count++) {
 311                 if (fsp->fnum == fnum) {
 312                         chain_fsp = fsp;
 313                         if (count > 10) {
 314                                 DLIST_PROMOTE(Files, fsp);
 315                         }
 316                         return fsp;
 317                 }
 318         }
 319         return NULL;
 320 }
 321
 322 /****************************************************************************
 323  Reset the chained fsp - done at the start of a packet reply
 324 ****************************************************************************/
 325
 326 void file_chain_reset(void)
 327 {
 328         chain_fsp = NULL;
 329 }
 330
 331 /****************************************************************************
 332 Save the chained fsp - done when about to do an oplock break.
 333 ****************************************************************************/
 334
 335 void file_chain_save(void)
 336 {
 337         oplock_save_chain_fsp = chain_fsp;
 338 }
 339
 340 /****************************************************************************
 341 Restore the chained fsp - done after an oplock break.
 342 ****************************************************************************/
 343 void file_chain_restore(void)
 344 {
 345         chain_fsp = oplock_save_chain_fsp;
 346 }