Unix SMB/CIFS implementation.
Files[] structure handling
Copyright (C) Andrew Tridgell 1998
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
+#include "smbd/smbd.h"
#include "smbd/globals.h"
-
-#define VALID_FNUM(fnum) (((fnum) >= 0) && ((fnum) < real_max_open_files))
+#include "libcli/security/security.h"
+#include "util_tdb.h"
+#include <ccan/hash/hash.h>
+#include "lib/util/bitmap.h"
#define FILE_HANDLE_OFFSET 0x1000
/****************************************************************************
- Return a unique number identifying this fsp over the life of this pid.
+ Return a unique number identifying this fsp over the life of this pid,
+ and try to make it as globally unique as possible.
+ See bug #8995 for the details.
****************************************************************************/
-static unsigned long get_gen_count(void)
+static unsigned long get_gen_count(struct smbd_server_connection *sconn)
{
- if ((++file_gen_counter) == 0)
- return ++file_gen_counter;
- return file_gen_counter;
+ /*
+ * While fsp->fh->gen_id is 'unsigned long' currently
+ * (which might by 8 bytes),
+ * there's some oplock code which truncates it to
+ * uint32_t(using IVAL()).
+ */
+ if (sconn->file_gen_counter == 0) {
+ sconn->file_gen_counter = generate_random();
+ }
+ sconn->file_gen_counter += 1;
+ if (sconn->file_gen_counter >= UINT32_MAX) {
+ sconn->file_gen_counter = 0;
+ }
+ if (sconn->file_gen_counter == 0) {
+ sconn->file_gen_counter += 1;
+ }
+ return sconn->file_gen_counter;
}
/****************************************************************************
NTSTATUS file_new(struct smb_request *req, connection_struct *conn,
files_struct **result)
{
- int i;
+ struct smbd_server_connection *sconn = conn->sconn;
+ int i = -1;
files_struct *fsp;
NTSTATUS status;
- /* we want to give out file handles differently on each new
- connection because of a common bug in MS clients where they try to
- reuse a file descriptor from an earlier smb connection. This code
- increases the chance that the errant client will get an error rather
- than causing corruption */
- if (first_file == 0) {
- first_file = (sys_getpid() ^ (int)time(NULL)) % real_max_open_files;
- }
+ if (sconn->file_bmap != NULL) {
+
+ /*
+ * we want to give out file handles differently on each new
+ * connection because of a common bug in MS clients where they
+ * try to reuse a file descriptor from an earlier smb
+ * connection. This code increases the chance that the errant
+ * client will get an error rather than causing corruption
+ */
+ if (sconn->first_file == 0) {
+ sconn->first_file = (getpid() ^ (int)time(NULL));
+ sconn->first_file %= sconn->real_max_open_files;
+ }
- /* TODO: Port the id-tree implementation from Samba4 */
+ /* TODO: Port the id-tree implementation from Samba4 */
- i = bitmap_find(file_bmap, first_file);
- if (i == -1) {
- DEBUG(0,("ERROR! Out of file structures\n"));
- /* TODO: We have to unconditionally return a DOS error here,
- * W2k3 even returns ERRDOS/ERRnofids for ntcreate&x with
- * NTSTATUS negotiated */
- return NT_STATUS_TOO_MANY_OPENED_FILES;
+ i = bitmap_find(sconn->file_bmap, sconn->first_file);
+ if (i == -1) {
+ DEBUG(0,("ERROR! Out of file structures\n"));
+ /*
+ * TODO: We have to unconditionally return a DOS error
+ * here, W2k3 even returns ERRDOS/ERRnofids for
+ * ntcreate&x with NTSTATUS negotiated
+ */
+ return NT_STATUS_TOO_MANY_OPENED_FILES;
+ }
}
/*
* Make a child of the connection_struct as an fsp can't exist
- * indepenedent of a connection.
+ * independent of a connection.
*/
fsp = talloc_zero(conn, struct files_struct);
if (!fsp) {
fsp->fh->ref_count = 1;
fsp->fh->fd = -1;
+ fsp->fnum = -1;
fsp->conn = conn;
- fsp->fh->gen_id = get_gen_count();
+ fsp->fh->gen_id = get_gen_count(sconn);
GetTimeOfDay(&fsp->open_time);
- first_file = (i+1) % real_max_open_files;
+ if (sconn->file_bmap != NULL) {
+ sconn->first_file = (i+1) % (sconn->real_max_open_files);
+
+ bitmap_set(sconn->file_bmap, i);
+
+ fsp->fnum = i + FILE_HANDLE_OFFSET;
+ SMB_ASSERT(fsp->fnum < 65536);
+ }
- bitmap_set(file_bmap, i);
- files_used++;
+ DLIST_ADD(sconn->files, fsp);
+ sconn->num_files += 1;
- fsp->fnum = i + FILE_HANDLE_OFFSET;
- SMB_ASSERT(fsp->fnum < 65536);
+ conn->num_files_open++;
/*
* Create an smb_filename with "" for the base_name. There are very
status = create_synthetic_smb_fname(fsp, "", NULL, NULL,
&fsp->fsp_name);
if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(fsp);
- TALLOC_FREE(fsp->fh);
+ file_free(NULL, fsp);
+ return status;
}
- DLIST_ADD(Files, fsp);
-
- DEBUG(5,("allocated file structure %d, fnum = %d (%d used)\n",
- i, fsp->fnum, files_used));
+ DEBUG(5,("allocated file structure %d, fnum = %d (%u used)\n",
+ i, fsp->fnum, (unsigned int)sconn->num_files));
if (req != NULL) {
req->chain_fsp = fsp;
at the start of the list and we search from
a cache hit to the *end* of the list. */
- ZERO_STRUCT(fsp_fi_cache);
-
- conn->num_files_open++;
+ ZERO_STRUCT(sconn->fsp_fi_cache);
*result = fsp;
return NT_STATUS_OK;
void file_close_conn(connection_struct *conn)
{
files_struct *fsp, *next;
-
- for (fsp=Files;fsp;fsp=next) {
+
+ for (fsp=conn->sconn->files; fsp; fsp=next) {
next = fsp->next;
if (fsp->conn == conn) {
close_file(NULL, fsp, SHUTDOWN_CLOSE);
Close all open files for a pid and a vuid.
****************************************************************************/
-void file_close_pid(uint16 smbpid, int vuid)
+void file_close_pid(struct smbd_server_connection *sconn, uint16 smbpid,
+ uint64_t vuid)
{
files_struct *fsp, *next;
-
- for (fsp=Files;fsp;fsp=next) {
+
+ for (fsp=sconn->files;fsp;fsp=next) {
next = fsp->next;
if ((fsp->file_pid == smbpid) && (fsp->vuid == vuid)) {
close_file(NULL, fsp, SHUTDOWN_CLOSE);
Initialise file structures.
****************************************************************************/
-#define MAX_OPEN_FUDGEFACTOR 20
+static int files_max_open_fds;
-void file_init(void)
+bool file_init_global(void)
{
- int request_max_open_files = lp_max_open_files();
+ int request_max = lp_max_open_files();
int real_lim;
+ int real_max;
+
+ if (files_max_open_fds != 0) {
+ return true;
+ }
/*
* Set the max_open files to be the requested
* max plus a fudgefactor to allow for the extra
* fd's we need such as log files etc...
*/
- real_lim = set_maxfiles(request_max_open_files + MAX_OPEN_FUDGEFACTOR);
+ real_lim = set_maxfiles(request_max + MAX_OPEN_FUDGEFACTOR);
- real_max_open_files = real_lim - MAX_OPEN_FUDGEFACTOR;
+ real_max = real_lim - MAX_OPEN_FUDGEFACTOR;
- if (real_max_open_files + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536)
- real_max_open_files = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
+ if (real_max + FILE_HANDLE_OFFSET + MAX_OPEN_PIPES > 65536) {
+ real_max = 65536 - FILE_HANDLE_OFFSET - MAX_OPEN_PIPES;
+ }
- if(real_max_open_files != request_max_open_files) {
- DEBUG(1,("file_init: Information only: requested %d \
-open files, %d are available.\n", request_max_open_files, real_max_open_files));
+ if (real_max != request_max) {
+ DEBUG(1, ("file_init_global: Information only: requested %d "
+ "open files, %d are available.\n",
+ request_max, real_max));
}
- SMB_ASSERT(real_max_open_files > 100);
+ SMB_ASSERT(real_max > 100);
+
+ files_max_open_fds = real_max;
+ return true;
+}
+
+bool file_init(struct smbd_server_connection *sconn)
+{
+ bool ok;
- file_bmap = bitmap_allocate(real_max_open_files);
-
- if (!file_bmap) {
- exit_server("out of memory in file_init");
+ ok = file_init_global();
+ if (!ok) {
+ return false;
}
+
+ sconn->real_max_open_files = files_max_open_fds;
+
+ sconn->file_bmap = bitmap_talloc(sconn, sconn->real_max_open_files);
+ if (!sconn->file_bmap) {
+ return false;
+ }
+
+ return true;
}
/****************************************************************************
Close files open by a specified vuid.
****************************************************************************/
-void file_close_user(int vuid)
+void file_close_user(struct smbd_server_connection *sconn, uint64_t vuid)
{
files_struct *fsp, *next;
- for (fsp=Files;fsp;fsp=next) {
+ for (fsp=sconn->files; fsp; fsp=next) {
next=fsp->next;
if (fsp->vuid == vuid) {
close_file(NULL, fsp, SHUTDOWN_CLOSE);
* Walk the files table until "fn" returns non-NULL
*/
-struct files_struct *file_walk_table(
+struct files_struct *files_forall(
+ struct smbd_server_connection *sconn,
struct files_struct *(*fn)(struct files_struct *fsp,
void *private_data),
void *private_data)
{
struct files_struct *fsp, *next;
- for (fsp = Files; fsp; fsp = next) {
+ for (fsp = sconn->files; fsp; fsp = next) {
struct files_struct *ret;
next = fsp->next;
ret = fn(fsp, private_data);
return NULL;
}
-/****************************************************************************
- Debug to enumerate all open files in the smbd.
-****************************************************************************/
-
-void file_dump_open_table(void)
-{
- int count=0;
- files_struct *fsp;
-
- for (fsp=Files;fsp;fsp=fsp->next,count++) {
- DEBUG(10,("Files[%d], fnum = %d, name %s, fd = %d, gen = %lu, "
- "fileid=%s\n", count, fsp->fnum, fsp_str_dbg(fsp),
- fsp->fh->fd, (unsigned long)fsp->fh->gen_id,
- file_id_string_tos(&fsp->file_id)));
- }
-}
-
/****************************************************************************
Find a fsp given a file descriptor.
****************************************************************************/
-files_struct *file_find_fd(int fd)
+files_struct *file_find_fd(struct smbd_server_connection *sconn, int fd)
{
int count=0;
files_struct *fsp;
- for (fsp=Files;fsp;fsp=fsp->next,count++) {
+ for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
if (fsp->fh->fd == fd) {
if (count > 10) {
- DLIST_PROMOTE(Files, fsp);
+ DLIST_PROMOTE(sconn->files, fsp);
}
return fsp;
}
Find a fsp given a device, inode and file_id.
****************************************************************************/
-files_struct *file_find_dif(struct file_id id, unsigned long gen_id)
+files_struct *file_find_dif(struct smbd_server_connection *sconn,
+ struct file_id id, unsigned long gen_id)
{
int count=0;
files_struct *fsp;
- for (fsp=Files;fsp;fsp=fsp->next,count++) {
+ if (gen_id == 0) {
+ return NULL;
+ }
+
+ for (fsp=sconn->files; fsp; fsp=fsp->next,count++) {
/* We can have a fsp->fh->fd == -1 here as it could be a stat open. */
if (file_id_equal(&fsp->file_id, &id) &&
fsp->fh->gen_id == gen_id ) {
if (count > 10) {
- DLIST_PROMOTE(Files, fsp);
+ DLIST_PROMOTE(sconn->files, fsp);
}
/* Paranoia check. */
if ((fsp->fh->fd == -1) &&
return NULL;
}
-/****************************************************************************
- Check if an fsp still exists.
-****************************************************************************/
-
-files_struct *file_find_fsp(files_struct *orig_fsp)
-{
- files_struct *fsp;
-
- for (fsp=Files;fsp;fsp=fsp->next) {
- if (fsp == orig_fsp)
- return fsp;
- }
-
- return NULL;
-}
-
/****************************************************************************
Find the first fsp given a device and inode.
We use a singleton cache here to speed up searching from getfilepathinfo
calls.
****************************************************************************/
-files_struct *file_find_di_first(struct file_id id)
+files_struct *file_find_di_first(struct smbd_server_connection *sconn,
+ struct file_id id)
{
files_struct *fsp;
- if (file_id_equal(&fsp_fi_cache.id, &id)) {
+ if (file_id_equal(&sconn->fsp_fi_cache.id, &id)) {
/* Positive or negative cache hit. */
- return fsp_fi_cache.fsp;
+ return sconn->fsp_fi_cache.fsp;
}
- fsp_fi_cache.id = id;
+ sconn->fsp_fi_cache.id = id;
- for (fsp=Files;fsp;fsp=fsp->next) {
+ for (fsp=sconn->files;fsp;fsp=fsp->next) {
if (file_id_equal(&fsp->file_id, &id)) {
/* Setup positive cache. */
- fsp_fi_cache.fsp = fsp;
+ sconn->fsp_fi_cache.fsp = fsp;
return fsp;
}
}
/* Setup negative cache. */
- fsp_fi_cache.fsp = NULL;
+ sconn->fsp_fi_cache.fsp = NULL;
return NULL;
}
return NULL;
}
-/****************************************************************************
- Find a fsp that is open for printing.
-****************************************************************************/
-
-files_struct *file_find_print(void)
-{
- files_struct *fsp;
-
- for (fsp=Files;fsp;fsp=fsp->next) {
- if (fsp->print_file) {
- return fsp;
- }
- }
-
- return NULL;
-}
-
/****************************************************************************
Find any fsp open with a pathname below that of an already open path.
****************************************************************************/
files_struct *fsp;
size_t dlen;
char *d_fullname = NULL;
- bool ret = false;
d_fullname = talloc_asprintf(talloc_tos(), "%s/%s",
dir_fsp->conn->connectpath,
dir_fsp->fsp_name->base_name);
if (!d_fullname) {
- goto out;
+ return false;
}
dlen = strlen(d_fullname);
- for (fsp=Files;fsp;fsp=fsp->next) {
+ for (fsp=dir_fsp->conn->sconn->files; fsp; fsp=fsp->next) {
char *d1_fullname;
if (fsp == dir_fsp) {
fsp->conn->connectpath,
fsp->fsp_name->base_name);
- if (strnequal(d_fullname, d1_fullname, dlen)) {
- int d1_len = strlen(d1_fullname);
-
- /*
- * If the open file is a second file handle to the
- * same name or is a stream on the original file, then
- * don't return true.
- */
- if (d1_len == dlen) {
- TALLOC_FREE(d1_fullname);
- continue;
- }
-
+ /*
+ * If the open file has a path that is a longer
+ * component, then it's a subpath.
+ */
+ if (strnequal(d_fullname, d1_fullname, dlen) &&
+ (d1_fullname[dlen] == '/')) {
TALLOC_FREE(d1_fullname);
- ret = true;
- goto out;
+ TALLOC_FREE(d_fullname);
+ return true;
}
TALLOC_FREE(d1_fullname);
- }
- out:
+ }
+
TALLOC_FREE(d_fullname);
- return ret;
+ return false;
}
/****************************************************************************
{
files_struct *fsp, *next;
- for (fsp=Files;fsp;fsp=next) {
+ for (fsp=conn->sconn->files; fsp; fsp=next) {
next=fsp->next;
if ((conn == fsp->conn) && (fsp->fh->fd != -1)) {
sync_file(conn, fsp, True /* write through */);
void file_free(struct smb_request *req, files_struct *fsp)
{
- DLIST_REMOVE(Files, fsp);
+ struct smbd_server_connection *sconn = fsp->conn->sconn;
+
+ DLIST_REMOVE(sconn->files, fsp);
+ SMB_ASSERT(sconn->num_files > 0);
+ sconn->num_files--;
TALLOC_FREE(fsp->fake_file_handle);
}
if (fsp->notify) {
- if (fsp->is_directory) {
- notify_remove_onelevel(fsp->conn->notify_ctx,
- &fsp->file_id, fsp);
- }
- notify_remove(fsp->conn->notify_ctx, fsp);
+ struct notify_context *notify_ctx =
+ fsp->conn->sconn->notify_ctx;
+ notify_remove(notify_ctx, fsp);
TALLOC_FREE(fsp->notify);
}
- /* Ensure this event will never fire. */
- TALLOC_FREE(fsp->oplock_timeout);
-
/* Ensure this event will never fire. */
TALLOC_FREE(fsp->update_write_time_event);
- bitmap_clear(file_bmap, fsp->fnum - FILE_HANDLE_OFFSET);
- files_used--;
-
- DEBUG(5,("freed files structure %d (%d used)\n",
- fsp->fnum, files_used));
+ if (sconn->file_bmap != NULL) {
+ bitmap_clear(sconn->file_bmap, fsp->fnum - FILE_HANDLE_OFFSET);
+ }
+ DEBUG(5,("freed files structure %d (%u used)\n",
+ fsp->fnum, (unsigned int)sconn->num_files));
fsp->conn->num_files_open--;
req->chain_fsp = NULL;
}
+ /*
+ * Clear all possible chained fsp
+ * pointers in the SMB2 request queue.
+ */
+ if (req != NULL && req->smb2req) {
+ remove_smb2_chained_fsp(fsp);
+ }
+
/* Closing a file can invalidate the positive cache. */
- if (fsp == fsp_fi_cache.fsp) {
- ZERO_STRUCT(fsp_fi_cache);
+ if (fsp == sconn->fsp_fi_cache.fsp) {
+ ZERO_STRUCT(sconn->fsp_fi_cache);
}
/* Drop all remaining extensions. */
- while (fsp->vfs_extension) {
- vfs_remove_fsp_extension(fsp->vfs_extension->owner, fsp);
- }
+ vfs_remove_all_fsp_extensions(fsp);
/* this is paranoia, just in case someone tries to reuse the
information */
Get an fsp from a 16 bit fnum.
****************************************************************************/
-files_struct *file_fnum(uint16 fnum)
+static struct files_struct *file_fnum(struct smbd_server_connection *sconn,
+ uint16 fnum)
{
files_struct *fsp;
int count=0;
- for (fsp=Files;fsp;fsp=fsp->next, count++) {
+ for (fsp=sconn->files; fsp; fsp=fsp->next, count++) {
+ if (fsp->fnum == -1) {
+ continue;
+ }
+
if (fsp->fnum == fnum) {
if (count > 10) {
- DLIST_PROMOTE(Files, fsp);
+ DLIST_PROMOTE(sconn->files, fsp);
}
return fsp;
}
}
/****************************************************************************
- Get an fsp from a packet given the offset of a 16 bit fnum.
+ Get an fsp from a packet given a 16 bit fnum.
****************************************************************************/
files_struct *file_fsp(struct smb_request *req, uint16 fid)
{
files_struct *fsp;
- if ((req != NULL) && (req->chain_fsp != NULL)) {
+ if (req == NULL) {
+ /*
+ * We should never get here. req==NULL could in theory
+ * only happen from internal opens with a non-zero
+ * root_dir_fid. Internal opens just don't do that, at
+ * least they are not supposed to do so. And if they
+ * start to do so, they better fake up a smb_request
+ * from which we get the right smbd_server_conn. While
+ * this should never happen, let's return NULL here.
+ */
+ return NULL;
+ }
+
+ if (req->chain_fsp != NULL) {
return req->chain_fsp;
}
- fsp = file_fnum(fid);
- if ((fsp != NULL) && (req != NULL)) {
+ fsp = file_fnum(req->sconn, fid);
+ if (fsp != NULL) {
req->chain_fsp = fsp;
}
return fsp;
}
+struct files_struct *file_fsp_smb2(struct smbd_smb2_request *smb2req,
+ uint64_t persistent_id,
+ uint64_t volatile_id)
+{
+ struct files_struct *fsp;
+
+ if (smb2req->compat_chain_fsp != NULL) {
+ return smb2req->compat_chain_fsp;
+ }
+
+ if (persistent_id != volatile_id) {
+ return NULL;
+ }
+
+ if (volatile_id > UINT16_MAX) {
+ return NULL;
+ }
+
+ fsp = file_fnum(smb2req->sconn, (uint16_t)volatile_id);
+ if (fsp == NULL) {
+ return NULL;
+ }
+
+ if (smb2req->tcon == NULL) {
+ return NULL;
+ }
+
+ if (smb2req->tcon->compat_conn != fsp->conn) {
+ return NULL;
+ }
+
+ if (smb2req->session == NULL) {
+ return NULL;
+ }
+
+ if (smb2req->session->vuid != fsp->vuid) {
+ return NULL;
+ }
+
+ smb2req->compat_chain_fsp = fsp;
+ return fsp;
+}
+
/****************************************************************************
Duplicate the file handle part for a DOS or FCB open.
****************************************************************************/
uint32 access_mask, uint32 share_access,
uint32 create_options, files_struct *to)
{
+ /* this can never happen for print files */
+ SMB_ASSERT(from->print_file == NULL);
+
TALLOC_FREE(to->fh);
to->fh = from->fh;
to->file_id = from->file_id;
to->initial_allocation_size = from->initial_allocation_size;
- to->mode = from->mode;
to->file_pid = from->file_pid;
to->vuid = from->vuid;
to->open_time = from->open_time;
to->share_access = share_access;
to->oplock_type = from->oplock_type;
to->can_lock = from->can_lock;
- to->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
- if (!CAN_WRITE(from->conn)) {
- to->can_write = False;
- } else {
- to->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
- }
- to->print_file = from->print_file;
+ to->can_read = ((access_mask & FILE_READ_DATA) != 0);
+ to->can_write =
+ CAN_WRITE(from->conn) &&
+ ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
to->modified = from->modified;
to->is_directory = from->is_directory;
to->aio_write_behind = from->aio_write_behind;
+
return fsp_set_smb_fname(to, from->fsp_name);
}
+/**
+ * Return a jenkins hash of a pathname on a connection.
+ */
+
+NTSTATUS file_name_hash(connection_struct *conn,
+ const char *name, uint32_t *p_name_hash)
+{
+ char *fullpath = NULL;
+
+ /* Set the hash of the full pathname. */
+ fullpath = talloc_asprintf(talloc_tos(),
+ "%s/%s",
+ conn->connectpath,
+ name);
+ if (!fullpath) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ *p_name_hash = hash(fullpath, talloc_get_size(fullpath), 0);
+
+ DEBUG(10,("file_name_hash: %s hash 0x%x\n",
+ fullpath,
+ (unsigned int)*p_name_hash ));
+
+ TALLOC_FREE(fullpath);
+ return NT_STATUS_OK;
+}
+
/**
* The only way that the fsp->fsp_name field should ever be set.
*/
TALLOC_FREE(fsp->fsp_name);
fsp->fsp_name = smb_fname_new;
- return NT_STATUS_OK;
+ return file_name_hash(fsp->conn,
+ smb_fname_str_dbg(fsp->fsp_name),
+ &fsp->name_hash);
}
git.samba.org / kai / samba-autobuild / .git / blobdiff