s3:smbd: s/struct timed_event/struct tevent_timer
[Samba/gebeck_regimport.git] / source3 / smbd / files.c
blobcba79aefcf072f3b876ca308ec29ef09ffa8521e
1 /*
2 Unix SMB/CIFS implementation.
3 Files[] structure handling
4 Copyright (C) Andrew Tridgell 1998
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.
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.
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/>.
20 #include "includes.h"
21 #include "smbd/smbd.h"
22 #include "smbd/globals.h"
23 #include "libcli/security/security.h"
24 #include "util_tdb.h"
25 #include <ccan/hash/hash.h>
26 #include "lib/util/bitmap.h"
28 #define FILE_HANDLE_OFFSET 0x1000
30 /**
31 * create new fsp to be used for file_new or a durable handle reconnect
33 NTSTATUS fsp_new(struct connection_struct *conn, TALLOC_CTX *mem_ctx,
34 files_struct **result)
36 NTSTATUS status = NT_STATUS_NO_MEMORY;
37 files_struct *fsp = NULL;
38 struct smbd_server_connection *sconn = conn->sconn;
40 fsp = talloc_zero(mem_ctx, struct files_struct);
41 if (fsp == NULL) {
42 goto fail;
46 * This can't be a child of fsp because the file_handle can be ref'd
47 * when doing a dos/fcb open, which will then share the file_handle
48 * across multiple fsps.
50 fsp->fh = talloc_zero(mem_ctx, struct fd_handle);
51 if (fsp->fh == NULL) {
52 goto fail;
55 fsp->fh->ref_count = 1;
56 fsp->fh->fd = -1;
58 fsp->fnum = FNUM_FIELD_INVALID;
59 fsp->conn = conn;
61 DLIST_ADD(sconn->files, fsp);
62 sconn->num_files += 1;
64 conn->num_files_open++;
66 *result = fsp;
67 return NT_STATUS_OK;
69 fail:
70 if (fsp != NULL) {
71 TALLOC_FREE(fsp->fh);
73 TALLOC_FREE(fsp);
75 return status;
78 /****************************************************************************
79 Find first available file slot.
80 ****************************************************************************/
82 NTSTATUS file_new(struct smb_request *req, connection_struct *conn,
83 files_struct **result)
85 struct smbd_server_connection *sconn = conn->sconn;
86 files_struct *fsp;
87 NTSTATUS status;
89 status = fsp_new(conn, conn, &fsp);
90 if (!NT_STATUS_IS_OK(status)) {
91 return status;
94 GetTimeOfDay(&fsp->open_time);
96 if (sconn->conn) {
97 struct smbXsrv_open *op = NULL;
98 NTTIME now = timeval_to_nttime(&fsp->open_time);
100 status = smbXsrv_open_create(sconn->conn,
101 conn->session_info,
102 now, &op);
103 if (!NT_STATUS_IS_OK(status)) {
104 file_free(NULL, fsp);
105 return status;
107 fsp->op = op;
108 op->compat = fsp;
109 fsp->fnum = op->local_id;
110 fsp->fh->gen_id = smbXsrv_open_hash(op);
114 * Create an smb_filename with "" for the base_name. There are very
115 * few NULL checks, so make sure it's initialized with something. to
116 * be safe until an audit can be done.
118 status = create_synthetic_smb_fname(fsp, "", NULL, NULL,
119 &fsp->fsp_name);
120 if (!NT_STATUS_IS_OK(status)) {
121 file_free(NULL, fsp);
122 return status;
125 DEBUG(5,("allocated file structure %s (%u used)\n",
126 fsp_fnum_dbg(fsp), (unsigned int)sconn->num_files));
128 if (req != NULL) {
129 fsp->mid = req->mid;
130 req->chain_fsp = fsp;
133 /* A new fsp invalidates the positive and
134 negative fsp_fi_cache as the new fsp is pushed
135 at the start of the list and we search from
136 a cache hit to the *end* of the list. */
138 ZERO_STRUCT(sconn->fsp_fi_cache);
140 *result = fsp;
141 return NT_STATUS_OK;
144 /****************************************************************************
145 Close all open files for a connection.
146 ****************************************************************************/
148 void file_close_conn(connection_struct *conn)
150 files_struct *fsp, *next;
152 for (fsp=conn->sconn->files; fsp; fsp=next) {
153 next = fsp->next;
154 if (fsp->conn != conn) {
155 continue;
157 if (fsp->op != NULL && fsp->op->global->durable) {
159 * A tree disconnect closes a durable handle
161 fsp->op->global->durable = false;
163 close_file(NULL, fsp, SHUTDOWN_CLOSE);
167 /****************************************************************************
168 Close all open files for a pid and a vuid.
169 ****************************************************************************/
171 void file_close_pid(struct smbd_server_connection *sconn, uint16 smbpid,
172 uint64_t vuid)
174 files_struct *fsp, *next;
176 for (fsp=sconn->files;fsp;fsp=next) {
177 next = fsp->next;
178 if ((fsp->file_pid == smbpid) && (fsp->vuid == vuid)) {
179 close_file(NULL, fsp, SHUTDOWN_CLOSE);
184 /****************************************************************************
185 Initialise file structures.
186 ****************************************************************************/
188 static int files_max_open_fds;
190 bool file_init_global(void)
192 int request_max = lp_max_open_files();
193 int real_lim;
194 int real_max;
196 if (files_max_open_fds != 0) {
197 return true;
201 * Set the max_open files to be the requested
202 * max plus a fudgefactor to allow for the extra
203 * fd's we need such as log files etc...
205 real_lim = set_maxfiles(request_max + MAX_OPEN_FUDGEFACTOR);
207 real_max = real_lim - MAX_OPEN_FUDGEFACTOR;
209 if (real_max + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536) {
210 real_max = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
213 if (real_max != request_max) {
214 DEBUG(1, ("file_init_global: Information only: requested %d "
215 "open files, %d are available.\n",
216 request_max, real_max));
219 SMB_ASSERT(real_max > 100);
221 files_max_open_fds = real_max;
222 return true;
225 bool file_init(struct smbd_server_connection *sconn)
227 bool ok;
229 ok = file_init_global();
230 if (!ok) {
231 return false;
234 sconn->real_max_open_files = files_max_open_fds;
236 return true;
239 /****************************************************************************
240 Close files open by a specified vuid.
241 ****************************************************************************/
243 void file_close_user(struct smbd_server_connection *sconn, uint64_t vuid)
245 files_struct *fsp, *next;
247 for (fsp=sconn->files; fsp; fsp=next) {
248 next=fsp->next;
249 if (fsp->vuid == vuid) {
250 close_file(NULL, fsp, SHUTDOWN_CLOSE);
256 * Walk the files table until "fn" returns non-NULL
259 struct files_struct *files_forall(
260 struct smbd_server_connection *sconn,
261 struct files_struct *(*fn)(struct files_struct *fsp,
262 void *private_data),
263 void *private_data)
265 struct files_struct *fsp, *next;
267 for (fsp = sconn->files; fsp; fsp = next) {
268 struct files_struct *ret;
269 next = fsp->next;
270 ret = fn(fsp, private_data);
271 if (ret != NULL) {
272 return ret;
275 return NULL;
278 /****************************************************************************
279 Find a fsp given a file descriptor.
280 ****************************************************************************/
282 files_struct *file_find_fd(struct smbd_server_connection *sconn, int fd)
284 int count=0;
285 files_struct *fsp;
287 for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
288 if (fsp->fh->fd == fd) {
289 if (count > 10) {
290 DLIST_PROMOTE(sconn->files, fsp);
292 return fsp;
296 return NULL;
299 /****************************************************************************
300 Find a fsp given a device, inode and file_id.
301 ****************************************************************************/
303 files_struct *file_find_dif(struct smbd_server_connection *sconn,
304 struct file_id id, unsigned long gen_id)
306 int count=0;
307 files_struct *fsp;
309 if (gen_id == 0) {
310 return NULL;
313 for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
314 /* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
315 if (file_id_equal(&fsp->file_id, &id) &&
316 fsp->fh->gen_id == gen_id ) {
317 if (count > 10) {
318 DLIST_PROMOTE(sconn->files, fsp);
320 /* Paranoia check. */
321 if ((fsp->fh->fd == -1) &&
322 (fsp->oplock_type != NO_OPLOCK) &&
323 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
324 DEBUG(0,("file_find_dif: file %s file_id = "
325 "%s, gen = %u oplock_type = %u is a "
326 "stat open with oplock type !\n",
327 fsp_str_dbg(fsp),
328 file_id_string_tos(&fsp->file_id),
329 (unsigned int)fsp->fh->gen_id,
330 (unsigned int)fsp->oplock_type ));
331 smb_panic("file_find_dif");
333 return fsp;
337 return NULL;
340 /****************************************************************************
341 Find the first fsp given a device and inode.
342 We use a singleton cache here to speed up searching from getfilepathinfo
343 calls.
344 ****************************************************************************/
346 files_struct *file_find_di_first(struct smbd_server_connection *sconn,
347 struct file_id id)
349 files_struct *fsp;
351 if (file_id_equal(&sconn->fsp_fi_cache.id, &id)) {
352 /* Positive or negative cache hit. */
353 return sconn->fsp_fi_cache.fsp;
356 sconn->fsp_fi_cache.id = id;
358 for (fsp=sconn->files;fsp;fsp=fsp->next) {
359 if (file_id_equal(&fsp->file_id, &id)) {
360 /* Setup positive cache. */
361 sconn->fsp_fi_cache.fsp = fsp;
362 return fsp;
366 /* Setup negative cache. */
367 sconn->fsp_fi_cache.fsp = NULL;
368 return NULL;
371 /****************************************************************************
372 Find the next fsp having the same device and inode.
373 ****************************************************************************/
375 files_struct *file_find_di_next(files_struct *start_fsp)
377 files_struct *fsp;
379 for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
380 if (file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
381 return fsp;
385 return NULL;
388 /****************************************************************************
389 Find any fsp open with a pathname below that of an already open path.
390 ****************************************************************************/
392 bool file_find_subpath(files_struct *dir_fsp)
394 files_struct *fsp;
395 size_t dlen;
396 char *d_fullname = NULL;
398 d_fullname = talloc_asprintf(talloc_tos(), "%s/%s",
399 dir_fsp->conn->connectpath,
400 dir_fsp->fsp_name->base_name);
402 if (!d_fullname) {
403 return false;
406 dlen = strlen(d_fullname);
408 for (fsp=dir_fsp->conn->sconn->files; fsp; fsp=fsp->next) {
409 char *d1_fullname;
411 if (fsp == dir_fsp) {
412 continue;
415 d1_fullname = talloc_asprintf(talloc_tos(),
416 "%s/%s",
417 fsp->conn->connectpath,
418 fsp->fsp_name->base_name);
421 * If the open file has a path that is a longer
422 * component, then it's a subpath.
424 if (strnequal(d_fullname, d1_fullname, dlen) &&
425 (d1_fullname[dlen] == '/')) {
426 TALLOC_FREE(d1_fullname);
427 TALLOC_FREE(d_fullname);
428 return true;
430 TALLOC_FREE(d1_fullname);
433 TALLOC_FREE(d_fullname);
434 return false;
437 /****************************************************************************
438 Sync open files on a connection.
439 ****************************************************************************/
441 void file_sync_all(connection_struct *conn)
443 files_struct *fsp, *next;
445 for (fsp=conn->sconn->files; fsp; fsp=next) {
446 next=fsp->next;
447 if ((conn == fsp->conn) && (fsp->fh->fd != -1)) {
448 sync_file(conn, fsp, True /* write through */);
453 /****************************************************************************
454 Free up a fsp.
455 ****************************************************************************/
457 void fsp_free(files_struct *fsp)
459 struct smbd_server_connection *sconn = fsp->conn->sconn;
461 DLIST_REMOVE(sconn->files, fsp);
462 SMB_ASSERT(sconn->num_files > 0);
463 sconn->num_files--;
465 TALLOC_FREE(fsp->fake_file_handle);
467 if (fsp->fh->ref_count == 1) {
468 TALLOC_FREE(fsp->fh);
469 } else {
470 fsp->fh->ref_count--;
473 fsp->conn->num_files_open--;
475 /* this is paranoia, just in case someone tries to reuse the
476 information */
477 ZERO_STRUCTP(fsp);
479 /* fsp->fsp_name is a talloc child and is free'd automatically. */
480 TALLOC_FREE(fsp);
483 void file_free(struct smb_request *req, files_struct *fsp)
485 struct smbd_server_connection *sconn = fsp->conn->sconn;
486 uint64_t fnum = fsp->fnum;
488 if (fsp->notify) {
489 struct notify_context *notify_ctx =
490 fsp->conn->sconn->notify_ctx;
491 notify_remove(notify_ctx, fsp);
492 TALLOC_FREE(fsp->notify);
495 /* Ensure this event will never fire. */
496 TALLOC_FREE(fsp->update_write_time_event);
498 if (fsp->op != NULL) {
499 fsp->op->compat = NULL;
501 TALLOC_FREE(fsp->op);
503 if ((req != NULL) && (fsp == req->chain_fsp)) {
504 req->chain_fsp = NULL;
508 * Clear all possible chained fsp
509 * pointers in the SMB2 request queue.
511 if (req != NULL && req->smb2req) {
512 remove_smb2_chained_fsp(fsp);
515 /* Closing a file can invalidate the positive cache. */
516 if (fsp == sconn->fsp_fi_cache.fsp) {
517 ZERO_STRUCT(sconn->fsp_fi_cache);
520 /* Drop all remaining extensions. */
521 vfs_remove_all_fsp_extensions(fsp);
523 fsp_free(fsp);
525 DEBUG(5,("freed files structure %llu (%u used)\n",
526 (unsigned long long)fnum, (unsigned int)sconn->num_files));
529 /****************************************************************************
530 Get an fsp from a packet given a 16 bit fnum.
531 ****************************************************************************/
533 files_struct *file_fsp(struct smb_request *req, uint16 fid)
535 struct smbXsrv_open *op;
536 NTSTATUS status;
537 NTTIME now = 0;
538 files_struct *fsp;
540 if (req == NULL) {
542 * We should never get here. req==NULL could in theory
543 * only happen from internal opens with a non-zero
544 * root_dir_fid. Internal opens just don't do that, at
545 * least they are not supposed to do so. And if they
546 * start to do so, they better fake up a smb_request
547 * from which we get the right smbd_server_conn. While
548 * this should never happen, let's return NULL here.
550 return NULL;
553 if (req->chain_fsp != NULL) {
554 if (req->chain_fsp->deferred_close) {
555 return NULL;
557 return req->chain_fsp;
560 if (req->sconn->conn == NULL) {
561 return NULL;
564 now = timeval_to_nttime(&req->request_time);
566 status = smb1srv_open_lookup(req->sconn->conn,
567 fid, now, &op);
568 if (!NT_STATUS_IS_OK(status)) {
569 return NULL;
572 fsp = op->compat;
573 if (fsp == NULL) {
574 return NULL;
577 if (fsp->deferred_close) {
578 return NULL;
581 req->chain_fsp = fsp;
582 return fsp;
585 struct files_struct *file_fsp_get(struct smbd_smb2_request *smb2req,
586 uint64_t persistent_id,
587 uint64_t volatile_id)
589 struct smbXsrv_open *op;
590 NTSTATUS status;
591 NTTIME now = 0;
592 struct files_struct *fsp;
594 now = timeval_to_nttime(&smb2req->request_time);
596 status = smb2srv_open_lookup(smb2req->sconn->conn,
597 persistent_id, volatile_id,
598 now, &op);
599 if (!NT_STATUS_IS_OK(status)) {
600 return NULL;
603 fsp = op->compat;
604 if (fsp == NULL) {
605 return NULL;
608 if (smb2req->tcon == NULL) {
609 return NULL;
612 if (smb2req->tcon->compat != fsp->conn) {
613 return NULL;
616 if (smb2req->session == NULL) {
617 return NULL;
620 if (smb2req->session->compat == NULL) {
621 return NULL;
624 if (smb2req->session->compat->vuid != fsp->vuid) {
625 return NULL;
628 if (fsp->deferred_close) {
629 return NULL;
632 return fsp;
635 struct files_struct *file_fsp_smb2(struct smbd_smb2_request *smb2req,
636 uint64_t persistent_id,
637 uint64_t volatile_id)
639 struct files_struct *fsp;
641 if (smb2req->compat_chain_fsp != NULL) {
642 if (smb2req->compat_chain_fsp->deferred_close) {
643 return NULL;
645 return smb2req->compat_chain_fsp;
648 fsp = file_fsp_get(smb2req, persistent_id, volatile_id);
649 if (fsp == NULL) {
650 return NULL;
653 smb2req->compat_chain_fsp = fsp;
654 return fsp;
657 /****************************************************************************
658 Duplicate the file handle part for a DOS or FCB open.
659 ****************************************************************************/
661 NTSTATUS dup_file_fsp(struct smb_request *req, files_struct *from,
662 uint32 access_mask, uint32 share_access,
663 uint32 create_options, files_struct *to)
665 /* this can never happen for print files */
666 SMB_ASSERT(from->print_file == NULL);
668 TALLOC_FREE(to->fh);
670 to->fh = from->fh;
671 to->fh->ref_count++;
673 to->file_id = from->file_id;
674 to->initial_allocation_size = from->initial_allocation_size;
675 to->file_pid = from->file_pid;
676 to->vuid = from->vuid;
677 to->open_time = from->open_time;
678 to->access_mask = access_mask;
679 to->share_access = share_access;
680 to->oplock_type = from->oplock_type;
681 to->can_lock = from->can_lock;
682 to->can_read = ((access_mask & FILE_READ_DATA) != 0);
683 to->can_write =
684 CAN_WRITE(from->conn) &&
685 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
686 to->modified = from->modified;
687 to->is_directory = from->is_directory;
688 to->aio_write_behind = from->aio_write_behind;
690 return fsp_set_smb_fname(to, from->fsp_name);
694 * Return a jenkins hash of a pathname on a connection.
697 NTSTATUS file_name_hash(connection_struct *conn,
698 const char *name, uint32_t *p_name_hash)
700 char *fullpath = NULL;
702 /* Set the hash of the full pathname. */
703 fullpath = talloc_asprintf(talloc_tos(),
704 "%s/%s",
705 conn->connectpath,
706 name);
707 if (!fullpath) {
708 return NT_STATUS_NO_MEMORY;
710 *p_name_hash = hash(fullpath, talloc_get_size(fullpath), 0);
712 DEBUG(10,("file_name_hash: %s hash 0x%x\n",
713 fullpath,
714 (unsigned int)*p_name_hash ));
716 TALLOC_FREE(fullpath);
717 return NT_STATUS_OK;
721 * The only way that the fsp->fsp_name field should ever be set.
723 NTSTATUS fsp_set_smb_fname(struct files_struct *fsp,
724 const struct smb_filename *smb_fname_in)
726 NTSTATUS status;
727 struct smb_filename *smb_fname_new;
729 status = copy_smb_filename(fsp, smb_fname_in, &smb_fname_new);
730 if (!NT_STATUS_IS_OK(status)) {
731 return status;
734 TALLOC_FREE(fsp->fsp_name);
735 fsp->fsp_name = smb_fname_new;
737 return file_name_hash(fsp->conn,
738 smb_fname_str_dbg(fsp->fsp_name),
739 &fsp->name_hash);