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 <ccan/hash/hash.h>
26 #include "lib/util/bitmap.h"
28 #define FILE_HANDLE_OFFSET 0x1000
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
);
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
) {
55 fsp
->fh
->ref_count
= 1;
58 fsp
->fnum
= FNUM_FIELD_INVALID
;
61 DLIST_ADD(sconn
->files
, fsp
);
62 sconn
->num_files
+= 1;
64 conn
->num_files_open
++;
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
;
89 status
= fsp_new(conn
, conn
, &fsp
);
90 if (!NT_STATUS_IS_OK(status
)) {
94 GetTimeOfDay(&fsp
->open_time
);
97 struct smbXsrv_connection
*xconn
= req
->xconn
;
98 struct smbXsrv_open
*op
= NULL
;
99 NTTIME now
= timeval_to_nttime(&fsp
->open_time
);
101 status
= smbXsrv_open_create(xconn
,
104 if (!NT_STATUS_IS_OK(status
)) {
105 file_free(NULL
, fsp
);
110 fsp
->fnum
= op
->local_id
;
111 fsp
->fh
->gen_id
= smbXsrv_open_hash(op
);
113 DEBUG(10, ("%s: req==NULL, INTERNAL_OPEN_ONLY, smbXsrv_open "
114 "allocated\n", __func__
));
118 * Create an smb_filename with "" for the base_name. There are very
119 * few NULL checks, so make sure it's initialized with something. to
120 * be safe until an audit can be done.
122 fsp
->fsp_name
= synthetic_smb_fname(fsp
, "", NULL
, NULL
);
123 if (fsp
->fsp_name
== NULL
) {
124 file_free(NULL
, fsp
);
125 return NT_STATUS_NO_MEMORY
;
128 DEBUG(5,("allocated file structure %s (%u used)\n",
129 fsp_fnum_dbg(fsp
), (unsigned int)sconn
->num_files
));
133 req
->chain_fsp
= fsp
;
136 /* A new fsp invalidates the positive and
137 negative fsp_fi_cache as the new fsp is pushed
138 at the start of the list and we search from
139 a cache hit to the *end* of the list. */
141 ZERO_STRUCT(sconn
->fsp_fi_cache
);
147 /****************************************************************************
148 Close all open files for a connection.
149 ****************************************************************************/
151 void file_close_conn(connection_struct
*conn
)
153 files_struct
*fsp
, *next
;
155 for (fsp
=conn
->sconn
->files
; fsp
; fsp
=next
) {
157 if (fsp
->conn
!= conn
) {
160 if (fsp
->op
!= NULL
&& fsp
->op
->global
->durable
) {
162 * A tree disconnect closes a durable handle
164 fsp
->op
->global
->durable
= false;
166 close_file(NULL
, fsp
, SHUTDOWN_CLOSE
);
170 /****************************************************************************
171 Close all open files for a pid and a vuid.
172 ****************************************************************************/
174 void file_close_pid(struct smbd_server_connection
*sconn
, uint16 smbpid
,
177 files_struct
*fsp
, *next
;
179 for (fsp
=sconn
->files
;fsp
;fsp
=next
) {
181 if ((fsp
->file_pid
== smbpid
) && (fsp
->vuid
== vuid
)) {
182 close_file(NULL
, fsp
, SHUTDOWN_CLOSE
);
187 /****************************************************************************
188 Initialise file structures.
189 ****************************************************************************/
191 static int files_max_open_fds
;
193 bool file_init_global(void)
195 int request_max
= lp_max_open_files();
199 if (files_max_open_fds
!= 0) {
204 * Set the max_open files to be the requested
205 * max plus a fudgefactor to allow for the extra
206 * fd's we need such as log files etc...
208 real_lim
= set_maxfiles(request_max
+ MAX_OPEN_FUDGEFACTOR
);
210 real_max
= real_lim
- MAX_OPEN_FUDGEFACTOR
;
212 if (real_max
+ FILE_HANDLE_OFFSET
+ MAX_OPEN_PIPES
> 65536) {
213 real_max
= 65536 - FILE_HANDLE_OFFSET
- MAX_OPEN_PIPES
;
216 if (real_max
!= request_max
) {
217 DEBUG(1, ("file_init_global: Information only: requested %d "
218 "open files, %d are available.\n",
219 request_max
, real_max
));
222 SMB_ASSERT(real_max
> 100);
224 files_max_open_fds
= real_max
;
228 bool file_init(struct smbd_server_connection
*sconn
)
232 ok
= file_init_global();
237 sconn
->real_max_open_files
= files_max_open_fds
;
242 /****************************************************************************
243 Close files open by a specified vuid.
244 ****************************************************************************/
246 void file_close_user(struct smbd_server_connection
*sconn
, uint64_t vuid
)
248 files_struct
*fsp
, *next
;
250 for (fsp
=sconn
->files
; fsp
; fsp
=next
) {
252 if (fsp
->vuid
== vuid
) {
253 close_file(NULL
, fsp
, SHUTDOWN_CLOSE
);
259 * Walk the files table until "fn" returns non-NULL
262 struct files_struct
*files_forall(
263 struct smbd_server_connection
*sconn
,
264 struct files_struct
*(*fn
)(struct files_struct
*fsp
,
268 struct files_struct
*fsp
, *next
;
270 for (fsp
= sconn
->files
; fsp
; fsp
= next
) {
271 struct files_struct
*ret
;
273 ret
= fn(fsp
, private_data
);
281 /****************************************************************************
282 Find a fsp given a file descriptor.
283 ****************************************************************************/
285 files_struct
*file_find_fd(struct smbd_server_connection
*sconn
, int fd
)
290 for (fsp
=sconn
->files
; fsp
; fsp
=fsp
->next
,count
++) {
291 if (fsp
->fh
->fd
== fd
) {
293 DLIST_PROMOTE(sconn
->files
, fsp
);
302 /****************************************************************************
303 Find a fsp given a device, inode and file_id.
304 ****************************************************************************/
306 files_struct
*file_find_dif(struct smbd_server_connection
*sconn
,
307 struct file_id id
, unsigned long gen_id
)
316 for (fsp
=sconn
->files
; fsp
; fsp
=fsp
->next
,count
++) {
317 /* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
318 if (file_id_equal(&fsp
->file_id
, &id
) &&
319 fsp
->fh
->gen_id
== gen_id
) {
321 DLIST_PROMOTE(sconn
->files
, fsp
);
323 /* Paranoia check. */
324 if ((fsp
->fh
->fd
== -1) &&
325 (fsp
->oplock_type
!= NO_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 /****************************************************************************
391 Find any fsp open with a pathname below that of an already open path.
392 ****************************************************************************/
394 bool file_find_subpath(files_struct
*dir_fsp
)
398 char *d_fullname
= NULL
;
400 d_fullname
= talloc_asprintf(talloc_tos(), "%s/%s",
401 dir_fsp
->conn
->connectpath
,
402 dir_fsp
->fsp_name
->base_name
);
408 dlen
= strlen(d_fullname
);
410 for (fsp
=dir_fsp
->conn
->sconn
->files
; fsp
; fsp
=fsp
->next
) {
413 if (fsp
== dir_fsp
) {
417 d1_fullname
= talloc_asprintf(talloc_tos(),
419 fsp
->conn
->connectpath
,
420 fsp
->fsp_name
->base_name
);
423 * If the open file has a path that is a longer
424 * component, then it's a subpath.
426 if (strnequal(d_fullname
, d1_fullname
, dlen
) &&
427 (d1_fullname
[dlen
] == '/')) {
428 TALLOC_FREE(d1_fullname
);
429 TALLOC_FREE(d_fullname
);
432 TALLOC_FREE(d1_fullname
);
435 TALLOC_FREE(d_fullname
);
439 /****************************************************************************
440 Sync open files on a connection.
441 ****************************************************************************/
443 void file_sync_all(connection_struct
*conn
)
445 files_struct
*fsp
, *next
;
447 for (fsp
=conn
->sconn
->files
; fsp
; fsp
=next
) {
449 if ((conn
== fsp
->conn
) && (fsp
->fh
->fd
!= -1)) {
450 sync_file(conn
, fsp
, True
/* write through */);
455 /****************************************************************************
457 ****************************************************************************/
459 void fsp_free(files_struct
*fsp
)
461 struct smbd_server_connection
*sconn
= fsp
->conn
->sconn
;
463 DLIST_REMOVE(sconn
->files
, fsp
);
464 SMB_ASSERT(sconn
->num_files
> 0);
467 TALLOC_FREE(fsp
->fake_file_handle
);
469 if (fsp
->fh
->ref_count
== 1) {
470 TALLOC_FREE(fsp
->fh
);
472 fsp
->fh
->ref_count
--;
475 fsp
->conn
->num_files_open
--;
477 /* this is paranoia, just in case someone tries to reuse the
481 /* fsp->fsp_name is a talloc child and is free'd automatically. */
485 void file_free(struct smb_request
*req
, files_struct
*fsp
)
487 struct smbd_server_connection
*sconn
= fsp
->conn
->sconn
;
488 uint64_t fnum
= fsp
->fnum
;
491 struct notify_context
*notify_ctx
=
492 fsp
->conn
->sconn
->notify_ctx
;
493 notify_remove(notify_ctx
, fsp
);
494 TALLOC_FREE(fsp
->notify
);
497 /* Ensure this event will never fire. */
498 TALLOC_FREE(fsp
->update_write_time_event
);
500 if (fsp
->op
!= NULL
) {
501 fsp
->op
->compat
= NULL
;
503 TALLOC_FREE(fsp
->op
);
505 if ((req
!= NULL
) && (fsp
== req
->chain_fsp
)) {
506 req
->chain_fsp
= NULL
;
510 * Clear all possible chained fsp
511 * pointers in the SMB2 request queue.
513 if (req
!= NULL
&& req
->smb2req
) {
514 remove_smb2_chained_fsp(fsp
);
517 /* Closing a file can invalidate the positive cache. */
518 if (fsp
== sconn
->fsp_fi_cache
.fsp
) {
519 ZERO_STRUCT(sconn
->fsp_fi_cache
);
522 /* Drop all remaining extensions. */
523 vfs_remove_all_fsp_extensions(fsp
);
527 DEBUG(5,("freed files structure %llu (%u used)\n",
528 (unsigned long long)fnum
, (unsigned int)sconn
->num_files
));
531 /****************************************************************************
532 Get an fsp from a packet given a 16 bit fnum.
533 ****************************************************************************/
535 files_struct
*file_fsp(struct smb_request
*req
, uint16 fid
)
537 struct smbXsrv_open
*op
;
544 * We should never get here. req==NULL could in theory
545 * only happen from internal opens with a non-zero
546 * root_dir_fid. Internal opens just don't do that, at
547 * least they are not supposed to do so. And if they
548 * start to do so, they better fake up a smb_request
549 * from which we get the right smbd_server_conn. While
550 * this should never happen, let's return NULL here.
555 if (req
->chain_fsp
!= NULL
) {
556 if (req
->chain_fsp
->deferred_close
) {
559 return req
->chain_fsp
;
562 if (req
->xconn
== NULL
) {
566 now
= timeval_to_nttime(&req
->request_time
);
568 status
= smb1srv_open_lookup(req
->xconn
,
570 if (!NT_STATUS_IS_OK(status
)) {
579 if (fsp
->deferred_close
) {
583 req
->chain_fsp
= fsp
;
587 struct files_struct
*file_fsp_get(struct smbd_smb2_request
*smb2req
,
588 uint64_t persistent_id
,
589 uint64_t volatile_id
)
591 struct smbXsrv_open
*op
;
594 struct files_struct
*fsp
;
596 now
= timeval_to_nttime(&smb2req
->request_time
);
598 status
= smb2srv_open_lookup(smb2req
->xconn
,
599 persistent_id
, volatile_id
,
601 if (!NT_STATUS_IS_OK(status
)) {
610 if (smb2req
->tcon
== NULL
) {
614 if (smb2req
->tcon
->compat
!= fsp
->conn
) {
618 if (smb2req
->session
== NULL
) {
622 if (smb2req
->session
->compat
== NULL
) {
626 if (smb2req
->session
->compat
->vuid
!= fsp
->vuid
) {
630 if (fsp
->deferred_close
) {
637 struct files_struct
*file_fsp_smb2(struct smbd_smb2_request
*smb2req
,
638 uint64_t persistent_id
,
639 uint64_t volatile_id
)
641 struct files_struct
*fsp
;
643 if (smb2req
->compat_chain_fsp
!= NULL
) {
644 if (smb2req
->compat_chain_fsp
->deferred_close
) {
647 return smb2req
->compat_chain_fsp
;
650 fsp
= file_fsp_get(smb2req
, persistent_id
, volatile_id
);
655 smb2req
->compat_chain_fsp
= fsp
;
659 /****************************************************************************
660 Duplicate the file handle part for a DOS or FCB open.
661 ****************************************************************************/
663 NTSTATUS
dup_file_fsp(struct smb_request
*req
, files_struct
*from
,
664 uint32 access_mask
, uint32 share_access
,
665 uint32 create_options
, files_struct
*to
)
667 /* this can never happen for print files */
668 SMB_ASSERT(from
->print_file
== NULL
);
675 to
->file_id
= from
->file_id
;
676 to
->initial_allocation_size
= from
->initial_allocation_size
;
677 to
->file_pid
= from
->file_pid
;
678 to
->vuid
= from
->vuid
;
679 to
->open_time
= from
->open_time
;
680 to
->access_mask
= access_mask
;
681 to
->share_access
= share_access
;
682 to
->oplock_type
= from
->oplock_type
;
683 to
->can_lock
= from
->can_lock
;
684 to
->can_read
= ((access_mask
& FILE_READ_DATA
) != 0);
686 CAN_WRITE(from
->conn
) &&
687 ((access_mask
& (FILE_WRITE_DATA
| FILE_APPEND_DATA
)) != 0);
688 to
->modified
= from
->modified
;
689 to
->is_directory
= from
->is_directory
;
690 to
->aio_write_behind
= from
->aio_write_behind
;
692 return fsp_set_smb_fname(to
, from
->fsp_name
);
696 * Return a jenkins hash of a pathname on a connection.
699 NTSTATUS
file_name_hash(connection_struct
*conn
,
700 const char *name
, uint32_t *p_name_hash
)
702 char tmpbuf
[PATH_MAX
];
703 char *fullpath
, *to_free
;
706 /* Set the hash of the full pathname. */
708 len
= full_path_tos(conn
->connectpath
, name
, tmpbuf
, sizeof(tmpbuf
),
709 &fullpath
, &to_free
);
711 return NT_STATUS_NO_MEMORY
;
713 *p_name_hash
= hash(fullpath
, len
+1, 0);
715 DEBUG(10,("file_name_hash: %s hash 0x%x\n",
717 (unsigned int)*p_name_hash
));
719 TALLOC_FREE(to_free
);
724 * The only way that the fsp->fsp_name field should ever be set.
726 NTSTATUS
fsp_set_smb_fname(struct files_struct
*fsp
,
727 const struct smb_filename
*smb_fname_in
)
729 struct smb_filename
*smb_fname_new
;
731 smb_fname_new
= cp_smb_filename(fsp
, smb_fname_in
);
732 if (smb_fname_new
== NULL
) {
733 return NT_STATUS_NO_MEMORY
;
736 TALLOC_FREE(fsp
->fsp_name
);
737 fsp
->fsp_name
= smb_fname_new
;
739 return file_name_hash(fsp
->conn
,
740 smb_fname_str_dbg(fsp
->fsp_name
),