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/>.
21 #include "smbd/smbd.h"
22 #include "smbd/globals.h"
23 #include "libcli/security/security.h"
25 #include "lib/util/bitmap.h"
27 #define FILE_HANDLE_OFFSET 0x1000
30 * create new fsp to be used for file_new or a durable handle reconnect
32 NTSTATUS fsp_new(struct connection_struct *conn, TALLOC_CTX *mem_ctx,
33 files_struct **result)
35 NTSTATUS status = NT_STATUS_NO_MEMORY;
36 files_struct *fsp = NULL;
37 struct smbd_server_connection *sconn = conn->sconn;
39 fsp = talloc_zero(mem_ctx, struct files_struct);
45 * This can't be a child of fsp because the file_handle can be ref'd
46 * when doing a dos/fcb open, which will then share the file_handle
47 * across multiple fsps.
49 fsp->fh = talloc_zero(mem_ctx, struct fd_handle);
50 if (fsp->fh == NULL) {
54 fsp->fh->ref_count = 1;
57 fsp->fnum = FNUM_FIELD_INVALID;
60 DLIST_ADD(sconn->files, fsp);
61 sconn->num_files += 1;
63 conn->num_files_open++;
77 /****************************************************************************
78 Find first available file slot.
79 ****************************************************************************/
81 NTSTATUS file_new(struct smb_request *req, connection_struct *conn,
82 files_struct **result)
84 struct smbd_server_connection *sconn = conn->sconn;
88 status = fsp_new(conn, conn, &fsp);
89 if (!NT_STATUS_IS_OK(status)) {
93 GetTimeOfDay(&fsp->open_time);
96 struct smbXsrv_connection *xconn = req->xconn;
97 struct smbXsrv_open *op = NULL;
98 NTTIME now = timeval_to_nttime(&fsp->open_time);
100 status = smbXsrv_open_create(xconn,
103 if (!NT_STATUS_IS_OK(status)) {
104 file_free(NULL, fsp);
109 fsp->fnum = op->local_id;
110 fsp->fh->gen_id = smbXsrv_open_hash(op);
112 DEBUG(10, ("%s: req==NULL, INTERNAL_OPEN_ONLY, smbXsrv_open "
113 "allocated\n", __func__));
117 * Create an smb_filename with "" for the base_name. There are very
118 * few NULL checks, so make sure it's initialized with something. to
119 * be safe until an audit can be done.
121 fsp->fsp_name = synthetic_smb_fname(fsp, "", NULL, NULL, 0);
122 if (fsp->fsp_name == NULL) {
123 file_free(NULL, fsp);
124 return NT_STATUS_NO_MEMORY;
127 DEBUG(5,("allocated file structure %s (%u used)\n",
128 fsp_fnum_dbg(fsp), (unsigned int)sconn->num_files));
132 req->chain_fsp = fsp;
135 /* A new fsp invalidates the positive and
136 negative fsp_fi_cache as the new fsp is pushed
137 at the start of the list and we search from
138 a cache hit to the *end* of the list. */
140 ZERO_STRUCT(sconn->fsp_fi_cache);
146 /****************************************************************************
147 Close all open files for a connection.
148 ****************************************************************************/
150 void file_close_conn(connection_struct *conn)
152 files_struct *fsp, *next;
154 for (fsp=conn->sconn->files; fsp; fsp=next) {
156 if (fsp->conn != conn) {
159 if (fsp->op != NULL && fsp->op->global->durable) {
161 * A tree disconnect closes a durable handle
163 fsp->op->global->durable = false;
165 close_file(NULL, fsp, SHUTDOWN_CLOSE);
169 /****************************************************************************
170 Close all open files for a pid and a vuid.
171 ****************************************************************************/
173 void file_close_pid(struct smbd_server_connection *sconn, uint16_t smbpid,
176 files_struct *fsp, *next;
178 for (fsp=sconn->files;fsp;fsp=next) {
180 if ((fsp->file_pid == smbpid) && (fsp->vuid == vuid)) {
181 close_file(NULL, fsp, SHUTDOWN_CLOSE);
186 /****************************************************************************
187 Initialise file structures.
188 ****************************************************************************/
190 static int files_max_open_fds;
192 bool file_init_global(void)
194 int request_max = lp_max_open_files();
198 if (files_max_open_fds != 0) {
203 * Set the max_open files to be the requested
204 * max plus a fudgefactor to allow for the extra
205 * fd's we need such as log files etc...
207 real_lim = set_maxfiles(request_max + MAX_OPEN_FUDGEFACTOR);
209 real_max = real_lim - MAX_OPEN_FUDGEFACTOR;
211 if (real_max + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536) {
212 real_max = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
215 if (real_max != request_max) {
216 DEBUG(1, ("file_init_global: Information only: requested %d "
217 "open files, %d are available.\n",
218 request_max, real_max));
221 SMB_ASSERT(real_max > 100);
223 files_max_open_fds = real_max;
227 bool file_init(struct smbd_server_connection *sconn)
231 ok = file_init_global();
236 sconn->real_max_open_files = files_max_open_fds;
241 /****************************************************************************
242 Close files open by a specified vuid.
243 ****************************************************************************/
245 void file_close_user(struct smbd_server_connection *sconn, uint64_t vuid)
247 files_struct *fsp, *next;
249 for (fsp=sconn->files; fsp; fsp=next) {
251 if (fsp->vuid == vuid) {
252 close_file(NULL, fsp, SHUTDOWN_CLOSE);
258 * Walk the files table until "fn" returns non-NULL
261 struct files_struct *files_forall(
262 struct smbd_server_connection *sconn,
263 struct files_struct *(*fn)(struct files_struct *fsp,
267 struct files_struct *fsp, *next;
269 for (fsp = sconn->files; fsp; fsp = next) {
270 struct files_struct *ret;
272 ret = fn(fsp, private_data);
280 /****************************************************************************
281 Find a fsp given a file descriptor.
282 ****************************************************************************/
284 files_struct *file_find_fd(struct smbd_server_connection *sconn, int fd)
289 for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
290 if (fsp->fh->fd == fd) {
292 DLIST_PROMOTE(sconn->files, fsp);
301 /****************************************************************************
302 Find a fsp given a device, inode and file_id.
303 ****************************************************************************/
305 files_struct *file_find_dif(struct smbd_server_connection *sconn,
306 struct file_id id, unsigned long gen_id)
315 for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
316 /* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
317 if (file_id_equal(&fsp->file_id, &id) &&
318 fsp->fh->gen_id == gen_id ) {
320 DLIST_PROMOTE(sconn->files, fsp);
322 /* Paranoia check. */
323 if ((fsp->fh->fd == -1) &&
324 (fsp->oplock_type != NO_OPLOCK &&
325 fsp->oplock_type != LEASE_OPLOCK)) {
326 DEBUG(0,("file_find_dif: file %s file_id = "
327 "%s, gen = %u oplock_type = %u is a "
328 "stat open with oplock type !\n",
330 file_id_string_tos(&fsp->file_id),
331 (unsigned int)fsp->fh->gen_id,
332 (unsigned int)fsp->oplock_type ));
333 smb_panic("file_find_dif");
342 /****************************************************************************
343 Find the first fsp given a device and inode.
344 We use a singleton cache here to speed up searching from getfilepathinfo
346 ****************************************************************************/
348 files_struct *file_find_di_first(struct smbd_server_connection *sconn,
353 if (file_id_equal(&sconn->fsp_fi_cache.id, &id)) {
354 /* Positive or negative cache hit. */
355 return sconn->fsp_fi_cache.fsp;
358 sconn->fsp_fi_cache.id = id;
360 for (fsp=sconn->files;fsp;fsp=fsp->next) {
361 if (file_id_equal(&fsp->file_id, &id)) {
362 /* Setup positive cache. */
363 sconn->fsp_fi_cache.fsp = fsp;
368 /* Setup negative cache. */
369 sconn->fsp_fi_cache.fsp = NULL;
373 /****************************************************************************
374 Find the next fsp having the same device and inode.
375 ****************************************************************************/
377 files_struct *file_find_di_next(files_struct *start_fsp)
381 for (fsp = start_fsp->next;fsp;fsp=fsp->next) {
382 if (file_id_equal(&fsp->file_id, &start_fsp->file_id)) {
390 struct files_struct *file_find_one_fsp_from_lease_key(
391 struct smbd_server_connection *sconn,
392 const struct smb2_lease_key *lease_key)
394 struct files_struct *fsp;
396 for (fsp = sconn->files; fsp; fsp=fsp->next) {
397 if ((fsp->lease != NULL) &&
398 (fsp->lease->lease.lease_key.data[0] ==
399 lease_key->data[0]) &&
400 (fsp->lease->lease.lease_key.data[1] ==
401 lease_key->data[1])) {
408 /****************************************************************************
409 Find any fsp open with a pathname below that of an already open path.
410 ****************************************************************************/
412 bool file_find_subpath(files_struct *dir_fsp)
416 char *d_fullname = NULL;
418 d_fullname = talloc_asprintf(talloc_tos(), "%s/%s",
419 dir_fsp->conn->connectpath,
420 dir_fsp->fsp_name->base_name);
426 dlen = strlen(d_fullname);
428 for (fsp=dir_fsp->conn->sconn->files; fsp; fsp=fsp->next) {
431 if (fsp == dir_fsp) {
435 d1_fullname = talloc_asprintf(talloc_tos(),
437 fsp->conn->connectpath,
438 fsp->fsp_name->base_name);
441 * If the open file has a path that is a longer
442 * component, then it's a subpath.
444 if (strnequal(d_fullname, d1_fullname, dlen) &&
445 (d1_fullname[dlen] == '/')) {
446 TALLOC_FREE(d1_fullname);
447 TALLOC_FREE(d_fullname);
450 TALLOC_FREE(d1_fullname);
453 TALLOC_FREE(d_fullname);
457 /****************************************************************************
458 Sync open files on a connection.
459 ****************************************************************************/
461 void file_sync_all(connection_struct *conn)
463 files_struct *fsp, *next;
465 for (fsp=conn->sconn->files; fsp; fsp=next) {
467 if ((conn == fsp->conn) && (fsp->fh->fd != -1)) {
468 sync_file(conn, fsp, True /* write through */);
473 /****************************************************************************
475 ****************************************************************************/
477 void fsp_free(files_struct *fsp)
479 struct smbd_server_connection *sconn = fsp->conn->sconn;
481 if (fsp == sconn->fsp_fi_cache.fsp) {
482 ZERO_STRUCT(sconn->fsp_fi_cache);
485 DLIST_REMOVE(sconn->files, fsp);
486 SMB_ASSERT(sconn->num_files > 0);
489 TALLOC_FREE(fsp->fake_file_handle);
491 if (fsp->fh->ref_count == 1) {
492 TALLOC_FREE(fsp->fh);
494 fsp->fh->ref_count--;
497 if (fsp->lease != NULL) {
498 if (fsp->lease->ref_count == 1) {
499 TALLOC_FREE(fsp->lease);
501 fsp->lease->ref_count--;
505 fsp->conn->num_files_open--;
507 /* this is paranoia, just in case someone tries to reuse the
511 /* fsp->fsp_name is a talloc child and is free'd automatically. */
515 void file_free(struct smb_request *req, files_struct *fsp)
517 struct smbd_server_connection *sconn = fsp->conn->sconn;
518 uint64_t fnum = fsp->fnum;
521 size_t len = fsp_fullbasepath(fsp, NULL, 0);
522 char fullpath[len+1];
524 fsp_fullbasepath(fsp, fullpath, sizeof(fullpath));
527 * Avoid /. at the end of the path name. notify can't
530 if (len > 1 && fullpath[len-1] == '.' &&
531 fullpath[len-2] == '/') {
532 fullpath[len-2] = '\0';
535 notify_remove(fsp->conn->sconn->notify_ctx, fsp, fullpath);
536 TALLOC_FREE(fsp->notify);
539 /* Ensure this event will never fire. */
540 TALLOC_FREE(fsp->update_write_time_event);
542 if (fsp->op != NULL) {
543 fsp->op->compat = NULL;
545 TALLOC_FREE(fsp->op);
547 if ((req != NULL) && (fsp == req->chain_fsp)) {
548 req->chain_fsp = NULL;
552 * Clear all possible chained fsp
553 * pointers in the SMB2 request queue.
555 remove_smb2_chained_fsp(fsp);
557 /* Drop all remaining extensions. */
558 vfs_remove_all_fsp_extensions(fsp);
562 DEBUG(5,("freed files structure %llu (%u used)\n",
563 (unsigned long long)fnum, (unsigned int)sconn->num_files));
566 /****************************************************************************
567 Get an fsp from a packet given a 16 bit fnum.
568 ****************************************************************************/
570 files_struct *file_fsp(struct smb_request *req, uint16_t fid)
572 struct smbXsrv_open *op;
579 * We should never get here. req==NULL could in theory
580 * only happen from internal opens with a non-zero
581 * root_dir_fid. Internal opens just don't do that, at
582 * least they are not supposed to do so. And if they
583 * start to do so, they better fake up a smb_request
584 * from which we get the right smbd_server_conn. While
585 * this should never happen, let's return NULL here.
590 if (req->chain_fsp != NULL) {
591 if (req->chain_fsp->deferred_close) {
594 return req->chain_fsp;
597 if (req->xconn == NULL) {
601 now = timeval_to_nttime(&req->request_time);
603 status = smb1srv_open_lookup(req->xconn,
605 if (!NT_STATUS_IS_OK(status)) {
614 if (fsp->deferred_close) {
618 req->chain_fsp = fsp;
622 struct files_struct *file_fsp_get(struct smbd_smb2_request *smb2req,
623 uint64_t persistent_id,
624 uint64_t volatile_id)
626 struct smbXsrv_open *op;
629 struct files_struct *fsp;
631 now = timeval_to_nttime(&smb2req->request_time);
633 status = smb2srv_open_lookup(smb2req->xconn,
634 persistent_id, volatile_id,
636 if (!NT_STATUS_IS_OK(status)) {
645 if (smb2req->tcon == NULL) {
649 if (smb2req->tcon->compat != fsp->conn) {
653 if (smb2req->session == NULL) {
657 if (smb2req->session->compat == NULL) {
661 if (smb2req->session->compat->vuid != fsp->vuid) {
665 if (fsp->deferred_close) {
672 struct files_struct *file_fsp_smb2(struct smbd_smb2_request *smb2req,
673 uint64_t persistent_id,
674 uint64_t volatile_id)
676 struct files_struct *fsp;
678 if (smb2req->compat_chain_fsp != NULL) {
679 if (smb2req->compat_chain_fsp->deferred_close) {
682 return smb2req->compat_chain_fsp;
685 fsp = file_fsp_get(smb2req, persistent_id, volatile_id);
690 smb2req->compat_chain_fsp = fsp;
694 /****************************************************************************
695 Duplicate the file handle part for a DOS or FCB open.
696 ****************************************************************************/
698 NTSTATUS dup_file_fsp(struct smb_request *req, files_struct *from,
699 uint32_t access_mask, uint32_t share_access,
700 uint32_t create_options, files_struct *to)
702 /* this can never happen for print files */
703 SMB_ASSERT(from->print_file == NULL);
710 to->file_id = from->file_id;
711 to->initial_allocation_size = from->initial_allocation_size;
712 to->file_pid = from->file_pid;
713 to->vuid = from->vuid;
714 to->open_time = from->open_time;
715 to->access_mask = access_mask;
716 to->share_access = share_access;
717 to->oplock_type = from->oplock_type;
718 to->can_lock = from->can_lock;
719 to->can_read = ((access_mask & FILE_READ_DATA) != 0);
721 CAN_WRITE(from->conn) &&
722 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
723 to->modified = from->modified;
724 to->is_directory = from->is_directory;
725 to->aio_write_behind = from->aio_write_behind;
727 return fsp_set_smb_fname(to, from->fsp_name);
731 * Return a jenkins hash of a pathname on a connection.
734 NTSTATUS file_name_hash(connection_struct *conn,
735 const char *name, uint32_t *p_name_hash)
737 char tmpbuf[PATH_MAX];
738 char *fullpath, *to_free;
742 /* Set the hash of the full pathname. */
744 len = full_path_tos(conn->connectpath, name, tmpbuf, sizeof(tmpbuf),
745 &fullpath, &to_free);
747 return NT_STATUS_NO_MEMORY;
749 key = (TDB_DATA) { .dptr = (uint8_t *)fullpath, .dsize = len+1 };
750 *p_name_hash = tdb_jenkins_hash(&key);
752 DEBUG(10,("file_name_hash: %s hash 0x%x\n",
754 (unsigned int)*p_name_hash ));
756 TALLOC_FREE(to_free);
761 * The only way that the fsp->fsp_name field should ever be set.
763 NTSTATUS fsp_set_smb_fname(struct files_struct *fsp,
764 const struct smb_filename *smb_fname_in)
766 struct smb_filename *smb_fname_new;
768 smb_fname_new = cp_smb_filename(fsp, smb_fname_in);
769 if (smb_fname_new == NULL) {
770 return NT_STATUS_NO_MEMORY;
773 TALLOC_FREE(fsp->fsp_name);
774 fsp->fsp_name = smb_fname_new;
776 return file_name_hash(fsp->conn,
777 smb_fname_str_dbg(fsp->fsp_name),
781 const struct GUID *fsp_client_guid(const files_struct *fsp)
783 return &fsp->conn->sconn->client->connections->smb2.client.guid;
786 size_t fsp_fullbasepath(struct files_struct *fsp, char *buf, size_t buflen)
790 len = snprintf(buf, buflen, "%s/%s", fsp->conn->connectpath,
791 fsp->fsp_name->base_name);