source: branches/samba-3.2.x/source/smbd/files.c@ 204

Last change on this file since 204 was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 13.9 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Files[] structure handling
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 3 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, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21
22static int real_max_open_files;
23
24#define VALID_FNUM(fnum) (((fnum) >= 0) && ((fnum) < real_max_open_files))
25
26#define FILE_HANDLE_OFFSET 0x1000
27
28static struct bitmap *file_bmap;
29
30static files_struct *Files;
31
32/* a fsp to use when chaining */
33static files_struct *chain_fsp = NULL;
34
35static int files_used;
36
37/* A singleton cache to speed up searching by dev/inode. */
38static struct fsp_singleton_cache {
39 files_struct *fsp;
40 struct file_id id;
41} fsp_fi_cache;
42
43/****************************************************************************
44 Return a unique number identifying this fsp over the life of this pid.
45****************************************************************************/
46
47static unsigned long get_gen_count(void)
48{
49 static unsigned long file_gen_counter;
50
51 if ((++file_gen_counter) == 0)
52 return ++file_gen_counter;
53 return file_gen_counter;
54}
55
56/****************************************************************************
57 Find first available file slot.
58****************************************************************************/
59
60NTSTATUS file_new(connection_struct *conn, files_struct **result)
61{
62 int i;
63 static int first_file;
64 files_struct *fsp;
65
66 /* we want to give out file handles differently on each new
67 connection because of a common bug in MS clients where they try to
68 reuse a file descriptor from an earlier smb connection. This code
69 increases the chance that the errant client will get an error rather
70 than causing corruption */
71 if (first_file == 0) {
72 first_file = (sys_getpid() ^ (int)time(NULL)) % real_max_open_files;
73 }
74
75 /* TODO: Port the id-tree implementation from Samba4 */
76
77 i = bitmap_find(file_bmap, first_file);
78 if (i == -1) {
79 DEBUG(0,("ERROR! Out of file structures\n"));
80 /* TODO: We have to unconditionally return a DOS error here,
81 * W2k3 even returns ERRDOS/ERRnofids for ntcreate&x with
82 * NTSTATUS negotiated */
83 return NT_STATUS_TOO_MANY_OPENED_FILES;
84 }
85
86 fsp = SMB_MALLOC_P(files_struct);
87 if (!fsp) {
88 return NT_STATUS_NO_MEMORY;
89 }
90
91 ZERO_STRUCTP(fsp);
92
93 fsp->fh = SMB_MALLOC_P(struct fd_handle);
94 if (!fsp->fh) {
95 SAFE_FREE(fsp);
96 return NT_STATUS_NO_MEMORY;
97 }
98
99 ZERO_STRUCTP(fsp->fh);
100
101 fsp->fh->ref_count = 1;
102 fsp->fh->fd = -1;
103
104 fsp->conn = conn;
105 fsp->fh->gen_id = get_gen_count();
106 GetTimeOfDay(&fsp->open_time);
107
108 first_file = (i+1) % real_max_open_files;
109
110 bitmap_set(file_bmap, i);
111 files_used++;
112
113 fsp->fnum = i + FILE_HANDLE_OFFSET;
114 SMB_ASSERT(fsp->fnum < 65536);
115
116 string_set(&fsp->fsp_name,"");
117
118 DLIST_ADD(Files, fsp);
119
120 DEBUG(5,("allocated file structure %d, fnum = %d (%d used)\n",
121 i, fsp->fnum, files_used));
122
123 chain_fsp = fsp;
124
125 /* A new fsp invalidates a negative fsp_fi_cache. */
126 if (fsp_fi_cache.fsp == NULL) {
127 ZERO_STRUCT(fsp_fi_cache);
128 }
129
130 *result = fsp;
131 return NT_STATUS_OK;
132}
133
134/****************************************************************************
135 Close all open files for a connection.
136****************************************************************************/
137
138void file_close_conn(connection_struct *conn)
139{
140 files_struct *fsp, *next;
141
142 for (fsp=Files;fsp;fsp=next) {
143 next = fsp->next;
144 if (fsp->conn == conn) {
145 close_file(fsp,SHUTDOWN_CLOSE);
146 }
147 }
148}
149
150/****************************************************************************
151 Close all open files for a pid and a vuid.
152****************************************************************************/
153
154void file_close_pid(uint16 smbpid, int vuid)
155{
156 files_struct *fsp, *next;
157
158 for (fsp=Files;fsp;fsp=next) {
159 next = fsp->next;
160 if ((fsp->file_pid == smbpid) && (fsp->vuid == vuid)) {
161 close_file(fsp,SHUTDOWN_CLOSE);
162 }
163 }
164}
165
166/****************************************************************************
167 Initialise file structures.
168****************************************************************************/
169
170#define MAX_OPEN_FUDGEFACTOR 20
171
172void file_init(void)
173{
174 int request_max_open_files = lp_max_open_files();
175 int real_lim;
176
177 /*
178 * Set the max_open files to be the requested
179 * max plus a fudgefactor to allow for the extra
180 * fd's we need such as log files etc...
181 */
182 real_lim = set_maxfiles(request_max_open_files + MAX_OPEN_FUDGEFACTOR);
183
184 real_max_open_files = real_lim - MAX_OPEN_FUDGEFACTOR;
185
186 if (real_max_open_files + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536)
187 real_max_open_files = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
188
189 if(real_max_open_files != request_max_open_files) {
190 DEBUG(1,("file_init: Information only: requested %d \
191open files, %d are available.\n", request_max_open_files, real_max_open_files));
192 }
193
194 SMB_ASSERT(real_max_open_files > 100);
195
196 file_bmap = bitmap_allocate(real_max_open_files);
197
198 if (!file_bmap) {
199 exit_server("out of memory in file_init");
200 }
201
202 /*
203 * Ensure that pipe_handle_oppset is set correctly.
204 */
205 set_pipe_handle_offset(real_max_open_files);
206}
207
208/****************************************************************************
209 Close files open by a specified vuid.
210****************************************************************************/
211
212void file_close_user(int vuid)
213{
214 files_struct *fsp, *next;
215
216 for (fsp=Files;fsp;fsp=next) {
217 next=fsp->next;
218 if (fsp->vuid == vuid) {
219 close_file(fsp,SHUTDOWN_CLOSE);
220 }
221 }
222}
223
224/****************************************************************************
225 Debug to enumerate all open files in the smbd.
226****************************************************************************/
227
228void file_dump_open_table(void)
229{
230 int count=0;
231 files_struct *fsp;
232
233 for (fsp=Files;fsp;fsp=fsp->next,count++) {
234 DEBUG(10,("Files[%d], fnum = %d, name %s, fd = %d, gen = %lu, fileid=%s\n",
235 count, fsp->fnum, fsp->fsp_name, fsp->fh->fd, (unsigned long)fsp->fh->gen_id,
236 file_id_string_tos(&fsp->file_id)));
237 }
238}
239
240/****************************************************************************
241 Find a fsp given a file descriptor.
242****************************************************************************/
243
244files_struct *file_find_fd(int fd)
245{
246 int count=0;
247 files_struct *fsp;
248
249 for (fsp=Files;fsp;fsp=fsp->next,count++) {
250 if (fsp->fh->fd == fd) {
251 if (count > 10) {
252 DLIST_PROMOTE(Files, fsp);
253 }
254 return fsp;
255 }
256 }
257
258 return NULL;
259}
260
261/****************************************************************************
262 Find a fsp given a device, inode and file_id.
263****************************************************************************/
264
265files_struct *file_find_dif(struct file_id id, unsigned long gen_id)
266{
267 int count=0;
268 files_struct *fsp;
269
270 for (fsp=Files;fsp;fsp=fsp->next,count++) {
271 /* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
272 if (file_id_equal(&fsp->file_id, &id) &&
273 fsp->fh->gen_id == gen_id ) {
274 if (count > 10) {
275 DLIST_PROMOTE(Files, fsp);
276 }
277 /* Paranoia check. */
278 if ((fsp->fh->fd == -1) &&
279 (fsp->oplock_type != NO_OPLOCK) &&
280 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
281 DEBUG(0,("file_find_dif: file %s file_id = %s, gen = %u \
282oplock_type = %u is a stat open with oplock type !\n", fsp->fsp_name,
283 file_id_string_tos(&fsp->file_id),
284 (unsigned int)fsp->fh->gen_id,
285 (unsigned int)fsp->oplock_type ));
286 smb_panic("file_find_dif");
287 }
288 return fsp;
289 }
290 }
291
292 return NULL;
293}
294
295/****************************************************************************
296 Check if an fsp still exists.
297****************************************************************************/
298
299files_struct *file_find_fsp(files_struct *orig_fsp)
300{
301 files_struct *fsp;
302
303 for (fsp=Files;fsp;fsp=fsp->next) {
304 if (fsp == orig_fsp)
305 return fsp;
306 }
307
308 return NULL;
309}
310
311/****************************************************************************
312 Find the first fsp given a device and inode.
313 We use a singleton cache here to speed up searching from getfilepathinfo
314 calls.
315****************************************************************************/
316
317files_struct *file_find_di_first(struct file_id id)
318{
319 files_struct *fsp;
320
321 if (file_id_equal(&fsp_fi_cache.id, &id)) {
322 /* Positive or negative cache hit. */
323 return fsp_fi_cache.fsp;
324 }
325
326 fsp_fi_cache.id = id;
327
328 for (fsp=Files;fsp;fsp=fsp->next) {
329 if ( fsp->fh->fd != -1 &&
330 file_id_equal(&fsp->file_id, &id)) {
331 /* Setup positive cache. */
332 fsp_fi_cache.fsp = fsp;
333 return fsp;
334 }
335 }
336
337 /* Setup negative cache. */
338 fsp_fi_cache.fsp = NULL;
339 return NULL;
340}
341
342/****************************************************************************
343 Find the next fsp having the same device and inode.
344****************************************************************************/
345
346files_struct *file_find_di_next(files_struct *start_fsp)
347{
348 files_struct *fsp;
349
350 for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
351 if ( fsp->fh->fd != -1 &&
352 file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
353 return fsp;
354 }
355 }
356
357 return NULL;
358}
359
360/****************************************************************************
361 Find a fsp that is open for printing.
362****************************************************************************/
363
364files_struct *file_find_print(void)
365{
366 files_struct *fsp;
367
368 for (fsp=Files;fsp;fsp=fsp->next) {
369 if (fsp->print_file) {
370 return fsp;
371 }
372 }
373
374 return NULL;
375}
376
377/****************************************************************************
378 Sync open files on a connection.
379****************************************************************************/
380
381void file_sync_all(connection_struct *conn)
382{
383 files_struct *fsp, *next;
384
385 for (fsp=Files;fsp;fsp=next) {
386 next=fsp->next;
387 if ((conn == fsp->conn) && (fsp->fh->fd != -1)) {
388 sync_file(conn, fsp, True /* write through */);
389 }
390 }
391}
392
393/****************************************************************************
394 Free up a fsp.
395****************************************************************************/
396
397void file_free(files_struct *fsp)
398{
399 DLIST_REMOVE(Files, fsp);
400
401 string_free(&fsp->fsp_name);
402
403 if (fsp->fake_file_handle) {
404 destroy_fake_file_handle(&fsp->fake_file_handle);
405 }
406
407 if (fsp->fh->ref_count == 1) {
408 SAFE_FREE(fsp->fh);
409 } else {
410 fsp->fh->ref_count--;
411 }
412
413 if (fsp->notify) {
414 notify_remove(fsp->conn->notify_ctx, fsp);
415 TALLOC_FREE(fsp->notify);
416 }
417
418 /* Ensure this event will never fire. */
419 TALLOC_FREE(fsp->oplock_timeout);
420
421 /* Ensure this event will never fire. */
422 TALLOC_FREE(fsp->update_write_time_event);
423
424 bitmap_clear(file_bmap, fsp->fnum - FILE_HANDLE_OFFSET);
425 files_used--;
426
427 DEBUG(5,("freed files structure %d (%d used)\n",
428 fsp->fnum, files_used));
429
430 /* this is paranoia, just in case someone tries to reuse the
431 information */
432 ZERO_STRUCTP(fsp);
433
434 if (fsp == chain_fsp) {
435 chain_fsp = NULL;
436 }
437
438 /* Closing a file can invalidate the positive cache. */
439 if (fsp == fsp_fi_cache.fsp) {
440 ZERO_STRUCT(fsp_fi_cache);
441 }
442
443 /* Drop all remaining extensions. */
444 while (fsp->vfs_extension) {
445 vfs_remove_fsp_extension(fsp->vfs_extension->owner, fsp);
446 }
447
448 SAFE_FREE(fsp);
449}
450
451/****************************************************************************
452 Get an fsp from a 16 bit fnum.
453****************************************************************************/
454
455files_struct *file_fnum(uint16 fnum)
456{
457 files_struct *fsp;
458 int count=0;
459
460 for (fsp=Files;fsp;fsp=fsp->next, count++) {
461 if (fsp->fnum == fnum) {
462 if (count > 10) {
463 DLIST_PROMOTE(Files, fsp);
464 }
465 return fsp;
466 }
467 }
468 return NULL;
469}
470
471/****************************************************************************
472 Get an fsp from a packet given the offset of a 16 bit fnum.
473****************************************************************************/
474
475files_struct *file_fsp(uint16 fid)
476{
477 files_struct *fsp;
478
479 if (chain_fsp) {
480 return chain_fsp;
481 }
482
483 fsp = file_fnum(fid);
484 if (fsp) {
485 chain_fsp = fsp;
486 }
487 return fsp;
488}
489
490/****************************************************************************
491 Reset the chained fsp - done at the start of a packet reply.
492****************************************************************************/
493
494void file_chain_reset(void)
495{
496 chain_fsp = NULL;
497}
498
499/****************************************************************************
500 Duplicate the file handle part for a DOS or FCB open.
501****************************************************************************/
502
503NTSTATUS dup_file_fsp(files_struct *fsp,
504 uint32 access_mask,
505 uint32 share_access,
506 uint32 create_options,
507 files_struct **result)
508{
509 NTSTATUS status;
510 files_struct *dup_fsp;
511
512 status = file_new(fsp->conn, &dup_fsp);
513
514 if (!NT_STATUS_IS_OK(status)) {
515 return status;
516 }
517
518 SAFE_FREE(dup_fsp->fh);
519
520 dup_fsp->fh = fsp->fh;
521 dup_fsp->fh->ref_count++;
522
523 dup_fsp->file_id = fsp->file_id;
524 dup_fsp->initial_allocation_size = fsp->initial_allocation_size;
525 dup_fsp->mode = fsp->mode;
526 dup_fsp->file_pid = fsp->file_pid;
527 dup_fsp->vuid = fsp->vuid;
528 dup_fsp->open_time = fsp->open_time;
529 dup_fsp->access_mask = access_mask;
530 dup_fsp->share_access = share_access;
531 dup_fsp->oplock_type = fsp->oplock_type;
532 dup_fsp->can_lock = fsp->can_lock;
533 dup_fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
534 if (!CAN_WRITE(fsp->conn)) {
535 dup_fsp->can_write = False;
536 } else {
537 dup_fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
538 }
539 dup_fsp->print_file = fsp->print_file;
540 dup_fsp->modified = fsp->modified;
541 dup_fsp->is_directory = fsp->is_directory;
542 dup_fsp->is_stat = fsp->is_stat;
543 dup_fsp->aio_write_behind = fsp->aio_write_behind;
544 string_set(&dup_fsp->fsp_name,fsp->fsp_name);
545
546 *result = dup_fsp;
547 return NT_STATUS_OK;
548}
Note: See TracBrowser for help on using the repository browser.