2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* fs/cifs/cifssmb.c
|
|
|
|
*
|
2010-04-20 22:12:10 -06:00
|
|
|
* Copyright (C) International Business Machines Corp., 2002,2010
|
2005-04-16 16:20:36 -06:00
|
|
|
* Author(s): Steve French (sfrench@us.ibm.com)
|
|
|
|
*
|
|
|
|
* Contains the routines for constructing the SMB PDUs themselves
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Lesser General Public License as published
|
|
|
|
* by the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library 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 Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
|
|
* along with this library; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */
|
|
|
|
/* These are mostly routines that operate on a pathname, or on a tree id */
|
|
|
|
/* (mounted volume), but there are eight handle based routines which must be */
|
2007-04-23 16:07:35 -06:00
|
|
|
/* treated slightly differently for reconnection purposes since we never */
|
|
|
|
/* want to reuse a stale file handle and only the caller knows the file info */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/vfs.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/posix_acl_xattr.h>
|
2011-05-19 14:22:56 -06:00
|
|
|
#include <linux/pagemap.h>
|
2011-10-19 13:30:07 -06:00
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/task_io_accounting_ops.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "cifspdu.h"
|
|
|
|
#include "cifsglob.h"
|
2007-10-03 12:22:19 -06:00
|
|
|
#include "cifsacl.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "cifsproto.h"
|
|
|
|
#include "cifs_unicode.h"
|
|
|
|
#include "cifs_debug.h"
|
2011-10-19 13:30:07 -06:00
|
|
|
#include "fscache.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_CIFS_POSIX
|
|
|
|
static struct {
|
|
|
|
int index;
|
|
|
|
char *name;
|
|
|
|
} protocols[] = {
|
2006-05-31 16:40:51 -06:00
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
|
|
|
{LANMAN_PROT, "\2LM1.2X002"},
|
2006-09-29 22:13:17 -06:00
|
|
|
{LANMAN2_PROT, "\2LANMAN2.1"},
|
2006-05-31 16:40:51 -06:00
|
|
|
#endif /* weak password hashing for legacy clients */
|
2007-07-12 18:33:32 -06:00
|
|
|
{CIFS_PROT, "\2NT LM 0.12"},
|
2006-05-31 16:40:51 -06:00
|
|
|
{POSIX_PROT, "\2POSIX 2"},
|
2005-04-16 16:20:36 -06:00
|
|
|
{BAD_PROT, "\2"}
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
static struct {
|
|
|
|
int index;
|
|
|
|
char *name;
|
|
|
|
} protocols[] = {
|
2006-05-31 16:40:51 -06:00
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
|
|
|
{LANMAN_PROT, "\2LM1.2X002"},
|
2006-09-30 21:13:01 -06:00
|
|
|
{LANMAN2_PROT, "\2LANMAN2.1"},
|
2006-05-31 16:40:51 -06:00
|
|
|
#endif /* weak password hashing for legacy clients */
|
2007-07-07 13:25:05 -06:00
|
|
|
{CIFS_PROT, "\2NT LM 0.12"},
|
2005-04-16 16:20:36 -06:00
|
|
|
{BAD_PROT, "\2"}
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2006-05-31 16:40:51 -06:00
|
|
|
/* define the number of elements in the cifs dialect array */
|
|
|
|
#ifdef CONFIG_CIFS_POSIX
|
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
2006-09-29 22:13:17 -06:00
|
|
|
#define CIFS_NUM_PROT 4
|
2006-05-31 16:40:51 -06:00
|
|
|
#else
|
|
|
|
#define CIFS_NUM_PROT 2
|
|
|
|
#endif /* CIFS_WEAK_PW_HASH */
|
|
|
|
#else /* not posix */
|
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
2006-09-29 22:13:17 -06:00
|
|
|
#define CIFS_NUM_PROT 3
|
2006-05-31 16:40:51 -06:00
|
|
|
#else
|
|
|
|
#define CIFS_NUM_PROT 1
|
|
|
|
#endif /* CONFIG_CIFS_WEAK_PW_HASH */
|
|
|
|
#endif /* CIFS_POSIX */
|
|
|
|
|
2012-07-11 07:09:36 -06:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
/*
|
|
|
|
* On arches that have high memory, kmap address space is limited. By
|
|
|
|
* serializing the kmap operations on those arches, we ensure that we don't
|
|
|
|
* end up with a bunch of threads in writeback with partially mapped page
|
|
|
|
* arrays, stuck waiting for kmap to come back. That situation prevents
|
|
|
|
* progress and can deadlock.
|
|
|
|
*/
|
|
|
|
static DEFINE_MUTEX(cifs_kmap_mutex);
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
cifs_kmap_lock(void)
|
|
|
|
{
|
|
|
|
mutex_lock(&cifs_kmap_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
cifs_kmap_unlock(void)
|
|
|
|
{
|
|
|
|
mutex_unlock(&cifs_kmap_mutex);
|
|
|
|
}
|
|
|
|
#else /* !CONFIG_HIGHMEM */
|
|
|
|
#define cifs_kmap_lock() do { ; } while(0)
|
|
|
|
#define cifs_kmap_unlock() do { ; } while(0)
|
|
|
|
#endif /* CONFIG_HIGHMEM */
|
2011-10-19 13:30:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Mark as invalid, all open files on tree connections since they
|
|
|
|
were closed when session to server was lost */
|
2011-05-26 22:34:02 -06:00
|
|
|
static void mark_open_files_invalid(struct cifs_tcon *pTcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct cifsFileInfo *open_file = NULL;
|
2007-07-07 13:25:05 -06:00
|
|
|
struct list_head *tmp;
|
|
|
|
struct list_head *tmp1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* list all files open on tree connection and mark them invalid */
|
2010-10-15 13:34:03 -06:00
|
|
|
spin_lock(&cifs_file_list_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
|
2007-07-07 13:25:05 -06:00
|
|
|
open_file = list_entry(tmp, struct cifsFileInfo, tlist);
|
2008-08-08 15:10:16 -06:00
|
|
|
open_file->invalidHandle = true;
|
2009-09-21 04:47:50 -06:00
|
|
|
open_file->oplock_break_cancelled = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-10-15 13:34:03 -06:00
|
|
|
spin_unlock(&cifs_file_list_lock);
|
2005-04-28 23:41:08 -06:00
|
|
|
/* BB Add call to invalidate_inodes(sb) for all superblocks mounted
|
|
|
|
to this tcon */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-09-03 10:07:17 -06:00
|
|
|
/* reconnect the socket, tcon, and smb session if needed */
|
|
|
|
static int
|
2011-05-26 22:34:02 -06:00
|
|
|
cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
|
2009-09-03 10:07:17 -06:00
|
|
|
{
|
2011-07-28 10:40:36 -06:00
|
|
|
int rc;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_ses *ses;
|
2009-09-03 10:07:17 -06:00
|
|
|
struct TCP_Server_Info *server;
|
|
|
|
struct nls_table *nls_codepage;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
|
|
|
|
* tcp and smb session status done differently for those three - in the
|
|
|
|
* calling routine
|
|
|
|
*/
|
|
|
|
if (!tcon)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ses = tcon->ses;
|
|
|
|
server = ses->server;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* only tree disconnect, open, and write, (and ulogoff which does not
|
|
|
|
* have tcon) are allowed as we start force umount
|
|
|
|
*/
|
|
|
|
if (tcon->tidStatus == CifsExiting) {
|
|
|
|
if (smb_command != SMB_COM_WRITE_ANDX &&
|
|
|
|
smb_command != SMB_COM_OPEN_ANDX &&
|
|
|
|
smb_command != SMB_COM_TREE_DISCONNECT) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "can not send cmd %d while umounting",
|
|
|
|
smb_command);
|
2009-09-03 10:07:17 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give demultiplex thread up to 10 seconds to reconnect, should be
|
|
|
|
* greater than cifs socket timeout which is 7 seconds
|
|
|
|
*/
|
|
|
|
while (server->tcpStatus == CifsNeedReconnect) {
|
|
|
|
wait_event_interruptible_timeout(server->response_q,
|
2011-04-11 19:01:14 -06:00
|
|
|
(server->tcpStatus != CifsNeedReconnect), 10 * HZ);
|
2009-09-03 10:07:17 -06:00
|
|
|
|
2011-04-11 19:01:14 -06:00
|
|
|
/* are we still trying to reconnect? */
|
2009-09-03 10:07:17 -06:00
|
|
|
if (server->tcpStatus != CifsNeedReconnect)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* on "soft" mounts we wait once. Hard mounts keep
|
|
|
|
* retrying until process is killed or server comes
|
|
|
|
* back on-line
|
|
|
|
*/
|
2011-02-07 06:54:35 -07:00
|
|
|
if (!tcon->retry) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "gave up waiting on reconnect in smb_init");
|
2009-09-03 10:07:17 -06:00
|
|
|
return -EHOSTDOWN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ses->need_reconnect && !tcon->need_reconnect)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
nls_codepage = load_nls_default();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* need to prevent multiple threads trying to simultaneously
|
|
|
|
* reconnect the same SMB session
|
|
|
|
*/
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_lock(&ses->session_mutex);
|
2010-04-24 05:57:48 -06:00
|
|
|
rc = cifs_negotiate_protocol(0, ses);
|
|
|
|
if (rc == 0 && ses->need_reconnect)
|
2009-09-03 10:07:17 -06:00
|
|
|
rc = cifs_setup_session(0, ses, nls_codepage);
|
|
|
|
|
|
|
|
/* do we need to reconnect tcon? */
|
|
|
|
if (rc || !tcon->need_reconnect) {
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_unlock(&ses->session_mutex);
|
2009-09-03 10:07:17 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mark_open_files_invalid(tcon);
|
|
|
|
rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_unlock(&ses->session_mutex);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "reconnect tcon rc = %d", rc);
|
2009-09-03 10:07:17 -06:00
|
|
|
|
|
|
|
if (rc)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FIXME: check if wsize needs updated due to negotiated smb buffer
|
|
|
|
* size shrinking
|
|
|
|
*/
|
|
|
|
atomic_inc(&tconInfoReconnectCount);
|
|
|
|
|
|
|
|
/* tell server Unix caps we support */
|
|
|
|
if (ses->capabilities & CAP_UNIX)
|
|
|
|
reset_cifs_unix_caps(0, tcon, NULL, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Removed call to reopen open files here. It is safer (and faster) to
|
|
|
|
* reopen files one at a time as needed in read and write.
|
|
|
|
*
|
|
|
|
* FIXME: what about file locks? don't we need to reclaim them ASAP?
|
|
|
|
*/
|
|
|
|
|
|
|
|
out:
|
|
|
|
/*
|
|
|
|
* Check if handle based operation so we know whether we can continue
|
|
|
|
* or not without returning to caller to reset file handle
|
|
|
|
*/
|
|
|
|
switch (smb_command) {
|
|
|
|
case SMB_COM_READ_ANDX:
|
|
|
|
case SMB_COM_WRITE_ANDX:
|
|
|
|
case SMB_COM_CLOSE:
|
|
|
|
case SMB_COM_FIND_CLOSE2:
|
|
|
|
case SMB_COM_LOCKING_ANDX:
|
|
|
|
rc = -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
unload_nls(nls_codepage);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-02-07 16:25:02 -07:00
|
|
|
/* Allocate and return pointer to an SMB request buffer, and set basic
|
|
|
|
SMB information in the SMB header. If the return code is zero, this
|
|
|
|
function must have filled in request_buf pointer */
|
2005-04-16 16:20:36 -06:00
|
|
|
static int
|
2011-05-26 22:34:02 -06:00
|
|
|
small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
|
2008-02-07 16:25:02 -07:00
|
|
|
void **request_buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-09-29 13:27:08 -06:00
|
|
|
int rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-03 10:07:17 -06:00
|
|
|
rc = cifs_reconnect_tcon(tcon, smb_command);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc)
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
*request_buf = cifs_small_buf_get();
|
|
|
|
if (*request_buf == NULL) {
|
|
|
|
/* BB should we add a retry in here if not a writepage? */
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-07-17 11:34:02 -06:00
|
|
|
header_assemble((struct smb_hdr *) *request_buf, smb_command,
|
2007-07-18 17:21:09 -06:00
|
|
|
tcon, wct);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon != NULL)
|
|
|
|
cifs_stats_inc(&tcon->num_smbs_sent);
|
2005-08-24 14:59:35 -06:00
|
|
|
|
2010-09-29 13:27:08 -06:00
|
|
|
return 0;
|
2006-02-13 18:36:20 -07:00
|
|
|
}
|
|
|
|
|
2006-02-09 14:12:47 -07:00
|
|
|
int
|
2007-07-12 18:33:32 -06:00
|
|
|
small_smb_init_no_tc(const int smb_command, const int wct,
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_ses *ses, void **request_buf)
|
2006-02-09 14:12:47 -07:00
|
|
|
{
|
|
|
|
int rc;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_hdr *buffer;
|
2006-02-09 14:12:47 -07:00
|
|
|
|
2006-02-13 18:36:20 -07:00
|
|
|
rc = small_smb_init(smb_command, wct, NULL, request_buf);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc)
|
2006-02-09 14:12:47 -07:00
|
|
|
return rc;
|
|
|
|
|
2006-02-09 22:52:50 -07:00
|
|
|
buffer = (struct smb_hdr *)*request_buf;
|
2012-05-23 04:01:59 -06:00
|
|
|
buffer->Mid = get_next_mid(ses->server);
|
2006-02-09 14:12:47 -07:00
|
|
|
if (ses->capabilities & CAP_UNICODE)
|
|
|
|
buffer->Flags2 |= SMBFLG2_UNICODE;
|
2006-02-09 22:52:50 -07:00
|
|
|
if (ses->capabilities & CAP_STATUS32)
|
2006-02-09 14:12:47 -07:00
|
|
|
buffer->Flags2 |= SMBFLG2_ERR_STATUS;
|
|
|
|
|
|
|
|
/* uid, tid can stay at zero as set in header assemble */
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* BB add support for turning on the signing when
|
2006-02-09 14:12:47 -07:00
|
|
|
this function is used after 1st of session setup requests */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* If the return code is zero, this function must fill in request_buf pointer */
|
|
|
|
static int
|
2011-05-26 22:34:02 -06:00
|
|
|
__smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
|
2010-09-29 13:27:08 -06:00
|
|
|
void **request_buf, void **response_buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
*request_buf = cifs_buf_get();
|
|
|
|
if (*request_buf == NULL) {
|
|
|
|
/* BB should we add a retry in here if not a writepage? */
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
/* Although the original thought was we needed the response buf for */
|
|
|
|
/* potential retries of smb operations it turns out we can determine */
|
|
|
|
/* from the mid flags when the request buffer can be resent without */
|
|
|
|
/* having to use a second distinct buffer for the response */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (response_buf)
|
2007-07-12 18:33:32 -06:00
|
|
|
*response_buf = *request_buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
|
2008-02-07 16:25:02 -07:00
|
|
|
wct);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon != NULL)
|
|
|
|
cifs_stats_inc(&tcon->num_smbs_sent);
|
2005-08-24 14:59:35 -06:00
|
|
|
|
2010-09-29 13:27:08 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the return code is zero, this function must fill in request_buf pointer */
|
|
|
|
static int
|
2011-05-26 22:34:02 -06:00
|
|
|
smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
|
2010-09-29 13:27:08 -06:00
|
|
|
void **request_buf, void **response_buf)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = cifs_reconnect_tcon(tcon, smb_command);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-05-26 22:34:02 -06:00
|
|
|
smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
|
2010-09-29 13:27:08 -06:00
|
|
|
void **request_buf, void **response_buf)
|
|
|
|
{
|
|
|
|
if (tcon->ses->need_reconnect || tcon->need_reconnect)
|
|
|
|
return -EHOSTDOWN;
|
|
|
|
|
|
|
|
return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
static int validate_t2(struct smb_t2_rsp *pSMB)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-01-20 11:36:51 -07:00
|
|
|
unsigned int total_size;
|
|
|
|
|
|
|
|
/* check for plausible wct */
|
|
|
|
if (pSMB->hdr.WordCount < 10)
|
|
|
|
goto vt2_err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check for parm and data offset going beyond end of smb */
|
2011-01-20 11:36:51 -07:00
|
|
|
if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
|
|
|
|
get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
|
|
|
|
goto vt2_err;
|
|
|
|
|
|
|
|
total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
|
|
|
|
if (total_size >= 512)
|
|
|
|
goto vt2_err;
|
|
|
|
|
2011-03-31 15:22:07 -06:00
|
|
|
/* check that bcc is at least as big as parms + data, and that it is
|
|
|
|
* less than negotiated smb buffer
|
|
|
|
*/
|
2011-01-20 11:36:51 -07:00
|
|
|
total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
|
|
|
|
if (total_size > get_bcc(&pSMB->hdr) ||
|
|
|
|
total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
|
|
|
|
goto vt2_err;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
vt2_err:
|
2007-07-12 18:33:32 -06:00
|
|
|
cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
|
2005-04-16 16:20:36 -06:00
|
|
|
sizeof(struct smb_t2_rsp) + 16);
|
2011-01-20 11:36:51 -07:00
|
|
|
return -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-01-20 11:36:51 -07:00
|
|
|
|
2011-04-28 23:40:20 -06:00
|
|
|
static inline void inc_rfc1001_len(void *pSMB, int count)
|
|
|
|
{
|
|
|
|
struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
|
|
|
|
|
|
|
|
be32_add_cpu(&hdr->smb_buf_length, count);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
NEGOTIATE_REQ *pSMB;
|
|
|
|
NEGOTIATE_RSP *pSMBr;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
2006-05-31 16:40:51 -06:00
|
|
|
int i;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct TCP_Server_Info *server;
|
2005-04-16 16:20:36 -06:00
|
|
|
u16 count;
|
2006-06-27 00:28:30 -06:00
|
|
|
unsigned int secFlags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (ses->server)
|
2005-04-16 16:20:36 -06:00
|
|
|
server = ses->server;
|
|
|
|
else {
|
|
|
|
rc = -EIO;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
|
|
|
|
(void **) &pSMB, (void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2006-06-27 00:28:30 -06:00
|
|
|
|
|
|
|
/* if any of auth flags (ie not sign or seal) are overriden use them */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
|
2007-06-28 12:41:42 -06:00
|
|
|
secFlags = ses->overrideSecFlg; /* BB FIXME fix sign flags? */
|
2006-06-27 00:28:30 -06:00
|
|
|
else /* if override flags set only sign/seal OR them with global auth */
|
2010-04-24 05:57:45 -06:00
|
|
|
secFlags = global_secflags | ses->overrideSecFlg;
|
2006-06-27 00:28:30 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "secFlags 0x%x", secFlags);
|
2006-06-27 18:13:38 -06:00
|
|
|
|
2012-05-23 04:01:59 -06:00
|
|
|
pSMB->hdr.Mid = get_next_mid(server);
|
2007-06-05 15:31:16 -06:00
|
|
|
pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
|
2007-10-04 14:05:09 -06:00
|
|
|
|
2007-06-05 15:31:16 -06:00
|
|
|
if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
|
2006-06-03 23:53:15 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
|
2007-10-04 14:05:09 -06:00
|
|
|
else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Kerberos only mechanism, enable extended security");
|
2007-10-04 14:05:09 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
|
2011-01-07 09:30:28 -07:00
|
|
|
} else if ((secFlags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
|
2009-05-05 22:16:04 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
|
|
|
|
else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_NTLMSSP) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "NTLMSSP only mechanism, enable extended security");
|
2009-05-05 22:16:04 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
|
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2006-05-31 16:40:51 -06:00
|
|
|
count = 0;
|
2007-07-12 18:33:32 -06:00
|
|
|
for (i = 0; i < CIFS_NUM_PROT; i++) {
|
2006-05-31 16:40:51 -06:00
|
|
|
strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
|
|
|
|
count += strlen(protocols[i].name) + 1;
|
|
|
|
/* null at end of source and target buffers anyway */
|
|
|
|
}
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2007-07-12 18:33:32 -06:00
|
|
|
if (rc != 0)
|
2006-06-03 23:53:15 -06:00
|
|
|
goto neg_err_exit;
|
|
|
|
|
2010-04-24 05:57:46 -06:00
|
|
|
server->dialect = le16_to_cpu(pSMBr->DialectIndex);
|
|
|
|
cFYI(1, "Dialect: %d", server->dialect);
|
2006-06-03 23:53:15 -06:00
|
|
|
/* Check wct = 1 error case */
|
2010-04-24 05:57:46 -06:00
|
|
|
if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
|
2006-06-03 23:53:15 -06:00
|
|
|
/* core returns wct = 1, but we do not ask for core - otherwise
|
2007-07-12 18:33:32 -06:00
|
|
|
small wct just comes when dialect index is -1 indicating we
|
2006-06-03 23:53:15 -06:00
|
|
|
could not negotiate a common dialect */
|
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
goto neg_err_exit;
|
2007-07-12 18:33:32 -06:00
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if ((pSMBr->hdr.WordCount == 13)
|
2010-04-24 05:57:46 -06:00
|
|
|
&& ((server->dialect == LANMAN_PROT)
|
|
|
|
|| (server->dialect == LANMAN2_PROT))) {
|
2006-10-01 23:53:29 -06:00
|
|
|
__s16 tmp;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
|
2006-06-03 23:53:15 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((secFlags & CIFSSEC_MAY_LANMAN) ||
|
2006-06-27 00:28:30 -06:00
|
|
|
(secFlags & CIFSSEC_MAY_PLNTXT))
|
2006-06-03 23:53:15 -06:00
|
|
|
server->secType = LANMAN;
|
|
|
|
else {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "mount failed weak security disabled"
|
|
|
|
" in /proc/fs/cifs/SecurityFlags");
|
2006-05-31 16:40:51 -06:00
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
goto neg_err_exit;
|
2007-07-12 18:33:32 -06:00
|
|
|
}
|
2011-05-26 22:34:02 -06:00
|
|
|
server->sec_mode = (__u8)le16_to_cpu(rsp->SecurityMode);
|
2012-03-20 03:55:09 -06:00
|
|
|
server->maxReq = min_t(unsigned int,
|
|
|
|
le16_to_cpu(rsp->MaxMpxCount),
|
|
|
|
cifs_max_pending);
|
2012-05-17 07:53:29 -06:00
|
|
|
set_credits(server, server->maxReq);
|
2011-10-11 04:41:32 -06:00
|
|
|
server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
|
[CIFS] Fix multiuser mounts so server does not invalidate earlier security contexts
When two different users mount the same Windows 2003 Server share using CIFS,
the first session mounted can be invalidated. Some servers invalidate the first
smb session when a second similar user (e.g. two users who get mapped by server to "guest")
authenticates an smb session from the same client.
By making sure that we set the 2nd and subsequent vc numbers to nonzero values,
this ensures that we will not have this problem.
Fixes Samba bug 6004, problem description follows:
How to reproduce:
- configure an "open share" (full permissions to Guest user) on Windows 2003
Server (I couldn't reproduce the problem with Samba server or Windows older
than 2003)
- mount the share twice with different users who will be authenticated as guest.
noacl,noperm,user=john,dir_mode=0700,domain=DOMAIN,rw
noacl,noperm,user=jeff,dir_mode=0700,domain=DOMAIN,rw
Result:
- just the mount point mounted last is accessible:
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-02-19 22:43:09 -07:00
|
|
|
server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
|
2006-06-03 23:53:15 -06:00
|
|
|
/* even though we do not use raw we might as well set this
|
|
|
|
accurately, in case we ever find a need for it */
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
|
[CIFS] Fix multiuser mounts so server does not invalidate earlier security contexts
When two different users mount the same Windows 2003 Server share using CIFS,
the first session mounted can be invalidated. Some servers invalidate the first
smb session when a second similar user (e.g. two users who get mapped by server to "guest")
authenticates an smb session from the same client.
By making sure that we set the 2nd and subsequent vc numbers to nonzero values,
this ensures that we will not have this problem.
Fixes Samba bug 6004, problem description follows:
How to reproduce:
- configure an "open share" (full permissions to Guest user) on Windows 2003
Server (I couldn't reproduce the problem with Samba server or Windows older
than 2003)
- mount the share twice with different users who will be authenticated as guest.
noacl,noperm,user=john,dir_mode=0700,domain=DOMAIN,rw
noacl,noperm,user=jeff,dir_mode=0700,domain=DOMAIN,rw
Result:
- just the mount point mounted last is accessible:
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-02-19 22:43:09 -07:00
|
|
|
server->max_rw = 0xFF00;
|
2006-06-03 23:53:15 -06:00
|
|
|
server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
|
|
|
|
} else {
|
[CIFS] Fix multiuser mounts so server does not invalidate earlier security contexts
When two different users mount the same Windows 2003 Server share using CIFS,
the first session mounted can be invalidated. Some servers invalidate the first
smb session when a second similar user (e.g. two users who get mapped by server to "guest")
authenticates an smb session from the same client.
By making sure that we set the 2nd and subsequent vc numbers to nonzero values,
this ensures that we will not have this problem.
Fixes Samba bug 6004, problem description follows:
How to reproduce:
- configure an "open share" (full permissions to Guest user) on Windows 2003
Server (I couldn't reproduce the problem with Samba server or Windows older
than 2003)
- mount the share twice with different users who will be authenticated as guest.
noacl,noperm,user=john,dir_mode=0700,domain=DOMAIN,rw
noacl,noperm,user=jeff,dir_mode=0700,domain=DOMAIN,rw
Result:
- just the mount point mounted last is accessible:
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-02-19 22:43:09 -07:00
|
|
|
server->max_rw = 0;/* do not need to use raw anyway */
|
2006-06-03 23:53:15 -06:00
|
|
|
server->capabilities = CAP_MPX_MODE;
|
|
|
|
}
|
2006-10-01 23:53:29 -06:00
|
|
|
tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
|
2006-10-01 23:59:18 -06:00
|
|
|
if (tmp == -1) {
|
2006-09-29 18:54:23 -06:00
|
|
|
/* OS/2 often does not set timezone therefore
|
|
|
|
* we must use server time to calc time zone.
|
2006-10-01 23:53:29 -06:00
|
|
|
* Could deviate slightly from the right zone.
|
|
|
|
* Smallest defined timezone difference is 15 minutes
|
|
|
|
* (i.e. Nepal). Rounding up/down is done to match
|
|
|
|
* this requirement.
|
2006-09-29 18:54:23 -06:00
|
|
|
*/
|
2006-10-01 23:53:29 -06:00
|
|
|
int val, seconds, remain, result;
|
2006-09-29 18:54:23 -06:00
|
|
|
struct timespec ts, utc;
|
|
|
|
utc = CURRENT_TIME;
|
2009-05-27 07:37:33 -06:00
|
|
|
ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
|
|
|
|
rsp->SrvTime.Time, 0);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SrvTime %d sec since 1970 (utc: %d) diff: %d",
|
2007-07-12 18:33:32 -06:00
|
|
|
(int)ts.tv_sec, (int)utc.tv_sec,
|
2010-04-20 21:50:45 -06:00
|
|
|
(int)(utc.tv_sec - ts.tv_sec));
|
2006-10-01 23:53:29 -06:00
|
|
|
val = (int)(utc.tv_sec - ts.tv_sec);
|
2007-08-30 14:18:41 -06:00
|
|
|
seconds = abs(val);
|
2006-10-01 23:55:25 -06:00
|
|
|
result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
|
2006-10-01 23:53:29 -06:00
|
|
|
remain = seconds % MIN_TZ_ADJ;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (remain >= (MIN_TZ_ADJ / 2))
|
2006-10-01 23:53:29 -06:00
|
|
|
result += MIN_TZ_ADJ;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (val < 0)
|
2008-02-07 16:25:02 -07:00
|
|
|
result = -result;
|
2006-10-01 23:53:29 -06:00
|
|
|
server->timeAdj = result;
|
2006-09-29 18:54:23 -06:00
|
|
|
} else {
|
2006-10-01 23:53:29 -06:00
|
|
|
server->timeAdj = (int)tmp;
|
|
|
|
server->timeAdj *= 60; /* also in seconds */
|
2006-09-29 18:54:23 -06:00
|
|
|
}
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "server->timeAdj: %d seconds", server->timeAdj);
|
2006-09-29 18:54:23 -06:00
|
|
|
|
2006-05-31 16:40:51 -06:00
|
|
|
|
2006-06-03 23:53:15 -06:00
|
|
|
/* BB get server time for time conversions and add
|
2007-07-12 18:33:32 -06:00
|
|
|
code to use it and timezone since this is not UTC */
|
2006-05-31 16:40:51 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
if (rsp->EncryptionKeyLength ==
|
2006-09-29 18:54:23 -06:00
|
|
|
cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
|
2010-10-27 14:20:36 -06:00
|
|
|
memcpy(ses->server->cryptkey, rsp->EncryptionKey,
|
2006-06-03 23:53:15 -06:00
|
|
|
CIFS_CRYPTO_KEY_SIZE);
|
2011-05-26 22:34:02 -06:00
|
|
|
} else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
|
2006-06-03 23:53:15 -06:00
|
|
|
rc = -EIO; /* need cryptkey unless plain text */
|
|
|
|
goto neg_err_exit;
|
|
|
|
}
|
2006-05-31 16:40:51 -06:00
|
|
|
|
2010-04-20 22:12:10 -06:00
|
|
|
cFYI(1, "LANMAN negotiated");
|
2006-06-03 23:53:15 -06:00
|
|
|
/* we will not end up setting signing flags - as no signing
|
|
|
|
was in LANMAN and server did not return the flags on */
|
|
|
|
goto signing_check;
|
2006-06-01 13:20:10 -06:00
|
|
|
#else /* weak security disabled */
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (pSMBr->hdr.WordCount == 13) {
|
2010-04-20 22:12:10 -06:00
|
|
|
cERROR(1, "mount failed, cifs module not built "
|
|
|
|
"with CIFS_WEAK_PW_HASH support");
|
2010-03-15 02:22:26 -06:00
|
|
|
rc = -EOPNOTSUPP;
|
2006-06-01 13:20:10 -06:00
|
|
|
#endif /* WEAK_PW_HASH */
|
2006-06-03 23:53:15 -06:00
|
|
|
goto neg_err_exit;
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (pSMBr->hdr.WordCount != 17) {
|
2006-06-03 23:53:15 -06:00
|
|
|
/* unknown wct */
|
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
goto neg_err_exit;
|
|
|
|
}
|
|
|
|
/* else wct == 17 NTLM */
|
2011-05-26 22:34:02 -06:00
|
|
|
server->sec_mode = pSMBr->SecurityMode;
|
|
|
|
if ((server->sec_mode & SECMODE_USER) == 0)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "share mode security");
|
2006-06-02 16:57:13 -06:00
|
|
|
|
2011-05-26 22:34:02 -06:00
|
|
|
if ((server->sec_mode & SECMODE_PW_ENCRYPT) == 0)
|
2006-06-02 16:57:13 -06:00
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
2006-06-27 00:28:30 -06:00
|
|
|
if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
|
2006-06-02 16:57:13 -06:00
|
|
|
#endif /* CIFS_WEAK_PW_HASH */
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Server requests plain text password"
|
|
|
|
" but client support disabled");
|
2006-06-04 16:21:07 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
|
2006-06-03 23:53:15 -06:00
|
|
|
server->secType = NTLMv2;
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (secFlags & CIFSSEC_MAY_NTLM)
|
2006-06-03 23:53:15 -06:00
|
|
|
server->secType = NTLM;
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (secFlags & CIFSSEC_MAY_NTLMV2)
|
2006-06-27 18:13:38 -06:00
|
|
|
server->secType = NTLMv2;
|
2007-10-04 14:05:09 -06:00
|
|
|
else if (secFlags & CIFSSEC_MAY_KRB5)
|
|
|
|
server->secType = Kerberos;
|
2009-05-05 22:16:04 -06:00
|
|
|
else if (secFlags & CIFSSEC_MAY_NTLMSSP)
|
2009-06-24 21:04:20 -06:00
|
|
|
server->secType = RawNTLMSSP;
|
2007-10-04 14:05:09 -06:00
|
|
|
else if (secFlags & CIFSSEC_MAY_LANMAN)
|
|
|
|
server->secType = LANMAN;
|
|
|
|
else {
|
|
|
|
rc = -EOPNOTSUPP;
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Invalid security type");
|
2007-10-04 14:05:09 -06:00
|
|
|
goto neg_err_exit;
|
|
|
|
}
|
|
|
|
/* else ... any others ...? */
|
2006-06-03 23:53:15 -06:00
|
|
|
|
|
|
|
/* one byte, so no need to convert this or EncryptionKeyLen from
|
|
|
|
little endian */
|
2012-03-20 03:55:09 -06:00
|
|
|
server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
|
|
|
|
cifs_max_pending);
|
2012-05-17 07:53:29 -06:00
|
|
|
set_credits(server, server->maxReq);
|
2006-06-03 23:53:15 -06:00
|
|
|
/* probably no need to store and check maxvcs */
|
2011-10-11 04:41:32 -06:00
|
|
|
server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
|
[CIFS] Fix multiuser mounts so server does not invalidate earlier security contexts
When two different users mount the same Windows 2003 Server share using CIFS,
the first session mounted can be invalidated. Some servers invalidate the first
smb session when a second similar user (e.g. two users who get mapped by server to "guest")
authenticates an smb session from the same client.
By making sure that we set the 2nd and subsequent vc numbers to nonzero values,
this ensures that we will not have this problem.
Fixes Samba bug 6004, problem description follows:
How to reproduce:
- configure an "open share" (full permissions to Guest user) on Windows 2003
Server (I couldn't reproduce the problem with Samba server or Windows older
than 2003)
- mount the share twice with different users who will be authenticated as guest.
noacl,noperm,user=john,dir_mode=0700,domain=DOMAIN,rw
noacl,noperm,user=jeff,dir_mode=0700,domain=DOMAIN,rw
Result:
- just the mount point mounted last is accessible:
Signed-off-by: Steve French <sfrench@us.ibm.com>
2009-02-19 22:43:09 -07:00
|
|
|
server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
|
2006-06-03 23:53:15 -06:00
|
|
|
server->capabilities = le32_to_cpu(pSMBr->Capabilities);
|
2006-10-01 23:53:29 -06:00
|
|
|
server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
|
|
|
|
server->timeAdj *= 60;
|
2006-06-03 23:53:15 -06:00
|
|
|
if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
|
2010-10-27 14:20:36 -06:00
|
|
|
memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
|
2006-06-03 23:53:15 -06:00
|
|
|
CIFS_CRYPTO_KEY_SIZE);
|
2011-05-26 22:12:29 -06:00
|
|
|
} else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
|
|
|
|
server->capabilities & CAP_EXTENDED_SECURITY) &&
|
|
|
|
(pSMBr->EncryptionKeyLength == 0)) {
|
2006-06-03 23:53:15 -06:00
|
|
|
/* decode security blob */
|
2011-05-04 06:05:26 -06:00
|
|
|
count = get_bcc(&pSMBr->hdr);
|
2007-10-16 11:10:44 -06:00
|
|
|
if (count < 16) {
|
2006-06-03 23:53:15 -06:00
|
|
|
rc = -EIO;
|
2007-10-16 11:10:44 -06:00
|
|
|
goto neg_err_exit;
|
|
|
|
}
|
2010-10-18 11:59:37 -06:00
|
|
|
spin_lock(&cifs_tcp_ses_lock);
|
2008-11-14 11:44:38 -07:00
|
|
|
if (server->srv_count > 1) {
|
2010-10-18 11:59:37 -06:00
|
|
|
spin_unlock(&cifs_tcp_ses_lock);
|
2007-10-16 11:10:44 -06:00
|
|
|
if (memcmp(server->server_GUID,
|
|
|
|
pSMBr->u.extended_response.
|
|
|
|
GUID, 16) != 0) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "server UID changed");
|
2006-06-03 23:53:15 -06:00
|
|
|
memcpy(server->server_GUID,
|
2007-10-16 11:10:44 -06:00
|
|
|
pSMBr->u.extended_response.GUID,
|
|
|
|
16);
|
|
|
|
}
|
2008-11-14 11:44:38 -07:00
|
|
|
} else {
|
2010-10-18 11:59:37 -06:00
|
|
|
spin_unlock(&cifs_tcp_ses_lock);
|
2007-10-16 11:10:44 -06:00
|
|
|
memcpy(server->server_GUID,
|
|
|
|
pSMBr->u.extended_response.GUID, 16);
|
2008-11-14 11:44:38 -07:00
|
|
|
}
|
2007-10-16 11:10:44 -06:00
|
|
|
|
|
|
|
if (count == 16) {
|
|
|
|
server->secType = RawNTLMSSP;
|
2006-06-03 23:53:15 -06:00
|
|
|
} else {
|
|
|
|
rc = decode_negTokenInit(pSMBr->u.extended_response.
|
2010-04-24 05:57:49 -06:00
|
|
|
SecurityBlob, count - 16,
|
|
|
|
server);
|
2008-07-24 09:56:05 -06:00
|
|
|
if (rc == 1)
|
2007-11-02 23:11:06 -06:00
|
|
|
rc = 0;
|
2008-07-24 09:56:05 -06:00
|
|
|
else
|
2006-06-03 23:53:15 -06:00
|
|
|
rc = -EINVAL;
|
cifs NTLMv2/NTLMSSP ntlmv2 within ntlmssp autentication code
Attribue Value (AV) pairs or Target Info (TI) pairs are part of
ntlmv2 authentication.
Structure ntlmv2_resp had only definition for two av pairs.
So removed it, and now allocation of av pairs is dynamic.
For servers like Windows 7/2008, av pairs sent by server in
challege packet (type 2 in the ntlmssp exchange/negotiation) can
vary.
Server sends them during ntlmssp negotiation. So when ntlmssp is used
as an authentication mechanism, type 2 challenge packet from server
has this information. Pluck it and use the entire blob for
authenticaiton purpose. If user has not specified, extract
(netbios) domain name from the av pairs which is used to calculate
ntlmv2 hash. Servers like Windows 7 are particular about the AV pair
blob.
Servers like Windows 2003, are not very strict about the contents
of av pair blob used during ntlmv2 authentication.
So when security mechanism such as ntlmv2 is used (not ntlmv2 in ntlmssp),
there is no negotiation and so genereate a minimal blob that gets
used in ntlmv2 authentication as well as gets sent.
Fields tilen and tilbob are session specific. AV pair values are defined.
To calculate ntlmv2 response we need ti/av pair blob.
For sec mech like ntlmssp, the blob is plucked from type 2 response from
the server. From this blob, netbios name of the domain is retrieved,
if user has not already provided, to be included in the Target String
as part of ntlmv2 hash calculations.
For sec mech like ntlmv2, create a minimal, two av pair blob.
The allocated blob is freed in case of error. In case there is no error,
this blob is used in calculating ntlmv2 response (in CalcNTLMv2_response)
and is also copied on the response to the server, and then freed.
The type 3 ntlmssp response is prepared on a buffer,
5 * sizeof of struct _AUTHENTICATE_MESSAGE, an empirical value large
enough to hold _AUTHENTICATE_MESSAGE plus a blob with max possible
10 values as part of ntlmv2 response and lmv2 keys and domain, user,
workstation names etc.
Also, kerberos gets selected as a default mechanism if server supports it,
over the other security mechanisms.
Signed-off-by: Shirish Pargaonkar <shirishpargaonkar@gmail.com>
Signed-off-by: Steve French <sfrench@us.ibm.com>
2010-09-18 21:02:18 -06:00
|
|
|
if (server->secType == Kerberos) {
|
|
|
|
if (!server->sec_kerberos &&
|
|
|
|
!server->sec_mskerberos)
|
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
} else if (server->secType == RawNTLMSSP) {
|
|
|
|
if (!server->sec_ntlmssp)
|
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
} else
|
|
|
|
rc = -EOPNOTSUPP;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-05-26 22:34:02 -06:00
|
|
|
} else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
|
2011-05-26 22:12:29 -06:00
|
|
|
rc = -EIO; /* no crypt key only if plain text pwd */
|
|
|
|
goto neg_err_exit;
|
2006-06-03 23:53:15 -06:00
|
|
|
} else
|
|
|
|
server->capabilities &= ~CAP_EXTENDED_SECURITY;
|
|
|
|
|
2006-06-11 22:18:35 -06:00
|
|
|
#ifdef CONFIG_CIFS_WEAK_PW_HASH
|
2006-06-03 23:53:15 -06:00
|
|
|
signing_check:
|
2006-06-11 22:18:35 -06:00
|
|
|
#endif
|
2007-06-28 12:41:42 -06:00
|
|
|
if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
|
|
|
|
/* MUST_SIGN already includes the MAY_SIGN FLAG
|
|
|
|
so if this is zero it means that signing is disabled */
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Signing disabled");
|
2011-05-26 22:34:02 -06:00
|
|
|
if (server->sec_mode & SECMODE_SIGN_REQUIRED) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Server requires "
|
2007-10-16 10:50:25 -06:00
|
|
|
"packet signing to be enabled in "
|
2010-04-20 21:50:45 -06:00
|
|
|
"/proc/fs/cifs/SecurityFlags.");
|
2007-10-17 20:58:40 -06:00
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
}
|
2011-05-26 22:34:02 -06:00
|
|
|
server->sec_mode &=
|
2006-06-03 23:53:15 -06:00
|
|
|
~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
|
2007-06-28 12:41:42 -06:00
|
|
|
} else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
|
|
|
|
/* signing required */
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Must sign - secFlags 0x%x", secFlags);
|
2011-05-26 22:34:02 -06:00
|
|
|
if ((server->sec_mode &
|
2007-06-28 12:41:42 -06:00
|
|
|
(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "signing required but server lacks support");
|
2007-07-06 15:10:07 -06:00
|
|
|
rc = -EOPNOTSUPP;
|
2007-06-28 12:41:42 -06:00
|
|
|
} else
|
2011-05-26 22:34:02 -06:00
|
|
|
server->sec_mode |= SECMODE_SIGN_REQUIRED;
|
2007-06-28 12:41:42 -06:00
|
|
|
} else {
|
|
|
|
/* signing optional ie CIFSSEC_MAY_SIGN */
|
2011-05-26 22:34:02 -06:00
|
|
|
if ((server->sec_mode & SECMODE_SIGN_REQUIRED) == 0)
|
|
|
|
server->sec_mode &=
|
2006-06-03 23:53:15 -06:00
|
|
|
~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
|
|
|
|
neg_err_exit:
|
2005-08-13 09:15:54 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2006-06-03 23:53:15 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "negprot rc %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_hdr *smb_buffer;
|
|
|
|
int rc = 0;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In tree disconnect");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-15 09:12:47 -07:00
|
|
|
/* BB: do we need to check this? These should never be NULL. */
|
|
|
|
if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
|
|
|
|
return -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-15 09:12:47 -07:00
|
|
|
/*
|
|
|
|
* No need to return error on this operation if tid invalidated and
|
|
|
|
* closed on server already e.g. due to tcp session crashing. Also,
|
|
|
|
* the tcon is no longer on the list, so no need to take lock before
|
|
|
|
* checking this.
|
|
|
|
*/
|
2009-06-24 18:29:21 -06:00
|
|
|
if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
|
2007-07-12 18:33:32 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
|
2005-04-28 23:41:08 -06:00
|
|
|
(void **)&smb_buffer);
|
2008-11-15 09:12:47 -07:00
|
|
|
if (rc)
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
2007-11-13 15:41:37 -07:00
|
|
|
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Tree disconnect failed %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* No need to return error on this operation if tid invalidated and
|
2008-11-15 09:12:47 -07:00
|
|
|
closed on server already e.g. due to tcp session crashing */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc == -EAGAIN)
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2011-01-11 05:24:21 -07:00
|
|
|
/*
|
|
|
|
* This is a no-op for now. We're not really interested in the reply, but
|
|
|
|
* rather in the fact that the server sent one and that server->lstrp
|
|
|
|
* gets updated.
|
|
|
|
*
|
|
|
|
* FIXME: maybe we should consider checking that the reply matches request?
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
cifs_echo_callback(struct mid_q_entry *mid)
|
|
|
|
{
|
|
|
|
struct TCP_Server_Info *server = mid->callback_data;
|
|
|
|
|
|
|
|
DeleteMidQEntry(mid);
|
2012-05-17 07:53:29 -06:00
|
|
|
add_credits(server, 1);
|
2011-01-11 05:24:21 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
CIFSSMBEcho(struct TCP_Server_Info *server)
|
|
|
|
{
|
|
|
|
ECHO_REQ *smb;
|
|
|
|
int rc = 0;
|
2011-05-19 14:22:53 -06:00
|
|
|
struct kvec iov;
|
2011-01-11 05:24:21 -07:00
|
|
|
|
|
|
|
cFYI(1, "In echo request");
|
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* set up echo request */
|
2011-03-12 22:08:25 -07:00
|
|
|
smb->hdr.Tid = 0xffff;
|
2011-01-20 19:19:25 -07:00
|
|
|
smb->hdr.WordCount = 1;
|
|
|
|
put_unaligned_le16(1, &smb->EchoCount);
|
2011-05-04 06:05:26 -06:00
|
|
|
put_bcc(1, &smb->hdr);
|
2011-01-11 05:24:21 -07:00
|
|
|
smb->Data[0] = 'a';
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(smb, 3);
|
2011-05-19 14:22:53 -06:00
|
|
|
iov.iov_base = smb;
|
|
|
|
iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
|
2011-01-11 05:24:21 -07:00
|
|
|
|
2011-10-19 13:29:49 -06:00
|
|
|
rc = cifs_call_async(server, &iov, 1, NULL, cifs_echo_callback,
|
|
|
|
server, true);
|
2011-01-11 05:24:21 -07:00
|
|
|
if (rc)
|
|
|
|
cFYI(1, "Echo request failed: %d", rc);
|
|
|
|
|
|
|
|
cifs_small_buf_release(smb);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
LOGOFF_ANDX_REQ *pSMB;
|
|
|
|
int rc = 0;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SMBLogoff for session disconnect");
|
2008-11-13 12:45:32 -07:00
|
|
|
|
2008-11-14 11:53:46 -07:00
|
|
|
/*
|
|
|
|
* BB: do we need to check validity of ses and server? They should
|
|
|
|
* always be valid since we have an active reference. If not, that
|
|
|
|
* should probably be a BUG()
|
|
|
|
*/
|
|
|
|
if (!ses || !ses->server)
|
2008-11-13 12:45:32 -07:00
|
|
|
return -EIO;
|
|
|
|
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_lock(&ses->session_mutex);
|
2008-11-13 12:45:32 -07:00
|
|
|
if (ses->need_reconnect)
|
|
|
|
goto session_already_dead; /* no need to send SMBlogoff if uid
|
|
|
|
already closed due to reconnect */
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
|
|
|
|
if (rc) {
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_unlock(&ses->session_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2012-05-23 04:01:59 -06:00
|
|
|
pSMB->hdr.Mid = get_next_mid(ses->server);
|
2005-08-17 13:38:22 -06:00
|
|
|
|
2011-05-26 22:34:02 -06:00
|
|
|
if (ses->server->sec_mode &
|
2005-04-16 16:20:36 -06:00
|
|
|
(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
|
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
|
|
|
|
|
|
|
|
pSMB->hdr.Uid = ses->Suid;
|
|
|
|
|
|
|
|
pSMB->AndXCommand = 0xFF;
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
|
2008-11-13 12:45:32 -07:00
|
|
|
session_already_dead:
|
2010-02-24 22:36:46 -07:00
|
|
|
mutex_unlock(&ses->session_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* if session dead then we do not need to do ulogoff,
|
2007-07-12 18:33:32 -06:00
|
|
|
since server closed smb session, no sense reporting
|
2005-04-16 16:20:36 -06:00
|
|
|
error */
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
rc = 0;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-07-14 19:48:57 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
|
2007-07-14 19:48:57 -06:00
|
|
|
__u16 type, const struct nls_table *nls_codepage, int remap)
|
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
struct unlink_psx_rq *pRqD;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In POSIX delete");
|
2007-07-14 19:48:57 -06:00
|
|
|
PsxDelete:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2007-07-14 19:48:57 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
} else { /* BB add path length overrun check */
|
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 6 + name_len;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
pSMB->MaxDataCount = 0; /* BB double check this with jra */
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
|
|
|
InformationLevel) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
/* Setup pointer to Request Data (inode type) */
|
|
|
|
pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
|
|
|
|
pRqD->type = cpu_to_le16(type);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
|
|
|
|
|
|
|
|
pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
|
|
|
|
pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2007-07-14 19:48:57 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Posix delete returned %d", rc);
|
2007-07-14 19:48:57 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
cifs_stats_inc(&tcon->num_deletes);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto PsxDelete;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
DELETE_FILE_REQ *pSMB = NULL;
|
|
|
|
DELETE_FILE_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
|
|
|
|
DelFileRetry:
|
|
|
|
rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->fileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2005-04-28 23:41:08 -06:00
|
|
|
} else { /* BB improve check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->fileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
pSMB->SearchAttributes =
|
|
|
|
cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
|
|
|
|
pSMB->BufferFormat = 0x04;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, name_len + 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(name_len + 1);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_deletes);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in RMFile = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto DelFileRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
DELETE_DIRECTORY_REQ *pSMB = NULL;
|
|
|
|
DELETE_DIRECTORY_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBRmDir");
|
2005-04-16 16:20:36 -06:00
|
|
|
RmDirRetry:
|
|
|
|
rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
2012-01-18 21:32:33 -07:00
|
|
|
name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, dirName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2005-04-28 23:41:08 -06:00
|
|
|
} else { /* BB improve check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(dirName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->DirName, dirName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
pSMB->BufferFormat = 0x04;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, name_len + 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(name_len + 1);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_rmdirs);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in RMDir = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto RmDirRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
|
2005-04-28 23:41:06 -06:00
|
|
|
const char *name, const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
CREATE_DIRECTORY_REQ *pSMB = NULL;
|
|
|
|
CREATE_DIRECTORY_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBMkDir");
|
2005-04-16 16:20:36 -06:00
|
|
|
MkDirRetry:
|
|
|
|
rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
2012-01-18 21:32:33 -07:00
|
|
|
name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2005-04-28 23:41:08 -06:00
|
|
|
} else { /* BB improve check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(name, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->DirName, name, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
pSMB->BufferFormat = 0x04;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, name_len + 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(name_len + 1);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_mkdirs);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in Mkdir = %d", rc);
|
2005-08-20 22:42:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto MkDirRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-04-23 16:07:35 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
|
2008-02-07 16:25:02 -07:00
|
|
|
__u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
|
2007-07-12 18:33:32 -06:00
|
|
|
__u32 *pOplock, const char *name,
|
2007-04-23 16:07:35 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
2008-02-07 16:25:02 -07:00
|
|
|
OPEN_PSX_REQ *pdata;
|
|
|
|
OPEN_PSX_RSP *psx_rsp;
|
2007-04-23 16:07:35 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In POSIX Create");
|
2007-04-23 16:07:35 -06:00
|
|
|
PsxCreat:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2007-04-23 16:07:35 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
|
|
|
name_len = strnlen(name, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, name, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 6 + name_len;
|
|
|
|
count = sizeof(OPEN_PSX_REQ);
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2007-04-23 16:07:35 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
|
2007-10-14 11:58:43 -06:00
|
|
|
pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
|
2007-04-23 16:07:35 -06:00
|
|
|
pdata->Permissions = cpu_to_le64(mode);
|
2007-07-12 18:33:32 -06:00
|
|
|
pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
|
2007-04-23 16:07:35 -06:00
|
|
|
pdata->OpenFlags = cpu_to_le32(*pOplock);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2007-04-23 16:07:35 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Posix create returned %d", rc);
|
2007-04-23 16:07:35 -06:00
|
|
|
goto psx_create_err;
|
|
|
|
}
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "copying inode info");
|
2007-04-23 16:07:35 -06:00
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
|
2007-04-23 16:07:35 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
goto psx_create_err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* copy return information to pRetData */
|
2007-07-12 18:33:32 -06:00
|
|
|
psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
|
2007-04-23 16:07:35 -06:00
|
|
|
+ le16_to_cpu(pSMBr->t2.DataOffset));
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2007-04-23 16:07:35 -06:00
|
|
|
*pOplock = le16_to_cpu(psx_rsp->OplockFlags);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (netfid)
|
2007-04-23 16:07:35 -06:00
|
|
|
*netfid = psx_rsp->Fid; /* cifs fid stays in le */
|
|
|
|
/* Let caller know file was created so we can set the mode. */
|
|
|
|
/* Do we care about the CreateAction in any other cases? */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
|
2007-04-23 16:07:35 -06:00
|
|
|
*pOplock |= CIFS_CREATE_ACTION;
|
|
|
|
/* check to make sure response data is there */
|
2007-10-14 11:58:43 -06:00
|
|
|
if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
|
|
|
|
pRetData->Type = cpu_to_le32(-1); /* unknown */
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(DBG2, "unknown type");
|
2007-04-25 05:46:06 -06:00
|
|
|
} else {
|
2011-05-04 06:05:26 -06:00
|
|
|
if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
|
2007-04-23 16:07:35 -06:00
|
|
|
+ sizeof(FILE_UNIX_BASIC_INFO)) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Open response data too small");
|
2007-10-14 11:58:43 -06:00
|
|
|
pRetData->Type = cpu_to_le32(-1);
|
2007-04-23 16:07:35 -06:00
|
|
|
goto psx_create_err;
|
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
memcpy((char *) pRetData,
|
2007-04-25 05:46:06 -06:00
|
|
|
(char *)psx_rsp + sizeof(OPEN_PSX_RSP),
|
2007-08-30 16:09:15 -06:00
|
|
|
sizeof(FILE_UNIX_BASIC_INFO));
|
2007-04-23 16:07:35 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
psx_create_err:
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
2009-07-10 09:27:25 -06:00
|
|
|
if (posix_flags & SMB_O_DIRECTORY)
|
|
|
|
cifs_stats_inc(&tcon->num_posixmkdirs);
|
|
|
|
else
|
|
|
|
cifs_stats_inc(&tcon->num_posixopens);
|
2007-04-23 16:07:35 -06:00
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto PsxCreat;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
return rc;
|
2007-04-23 16:07:35 -06:00
|
|
|
}
|
|
|
|
|
2005-08-25 00:06:05 -06:00
|
|
|
static __u16 convert_disposition(int disposition)
|
|
|
|
{
|
|
|
|
__u16 ofun = 0;
|
|
|
|
|
|
|
|
switch (disposition) {
|
|
|
|
case FILE_SUPERSEDE:
|
|
|
|
ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
|
|
|
|
break;
|
|
|
|
case FILE_OPEN:
|
|
|
|
ofun = SMBOPEN_OAPPEND;
|
|
|
|
break;
|
|
|
|
case FILE_CREATE:
|
|
|
|
ofun = SMBOPEN_OCREATE;
|
|
|
|
break;
|
|
|
|
case FILE_OPEN_IF:
|
|
|
|
ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
|
|
|
|
break;
|
|
|
|
case FILE_OVERWRITE:
|
|
|
|
ofun = SMBOPEN_OTRUNC;
|
|
|
|
break;
|
|
|
|
case FILE_OVERWRITE_IF:
|
|
|
|
ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
|
|
|
|
break;
|
|
|
|
default:
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "unknown disposition %d", disposition);
|
2005-08-25 00:06:05 -06:00
|
|
|
ofun = SMBOPEN_OAPPEND; /* regular open */
|
|
|
|
}
|
|
|
|
return ofun;
|
|
|
|
}
|
|
|
|
|
2008-05-14 11:22:03 -06:00
|
|
|
static int
|
|
|
|
access_flags_to_smbopen_mode(const int access_flags)
|
|
|
|
{
|
|
|
|
int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
|
|
|
|
|
|
|
|
if (masked_flags == GENERIC_READ)
|
|
|
|
return SMBOPEN_READ;
|
|
|
|
else if (masked_flags == GENERIC_WRITE)
|
|
|
|
return SMBOPEN_WRITE;
|
|
|
|
|
|
|
|
/* just go for read/write */
|
|
|
|
return SMBOPEN_READWRITE;
|
|
|
|
}
|
|
|
|
|
2005-08-25 00:06:05 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
|
2005-08-25 00:06:05 -06:00
|
|
|
const char *fileName, const int openDisposition,
|
2008-02-07 16:25:02 -07:00
|
|
|
const int access_flags, const int create_options, __u16 *netfid,
|
|
|
|
int *pOplock, FILE_ALL_INFO *pfile_info,
|
2005-08-25 00:06:05 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
|
|
|
{
|
|
|
|
int rc = -EACCES;
|
|
|
|
OPENX_REQ *pSMB = NULL;
|
|
|
|
OPENX_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 count;
|
|
|
|
|
|
|
|
OldOpenRetry:
|
|
|
|
rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
count = 1; /* account for one byte pad to word boundary */
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
|
|
|
|
fileName, PATH_MAX, nls_codepage, remap);
|
2005-08-25 00:06:05 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
} else { /* BB improve check for buffer overruns BB */
|
|
|
|
count = 0; /* no pad */
|
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->fileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
if (*pOplock & REQ_OPLOCK)
|
|
|
|
pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
|
2007-08-30 16:09:15 -06:00
|
|
|
else if (*pOplock & REQ_BATCHOPLOCK)
|
2005-08-25 00:06:05 -06:00
|
|
|
pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
|
2007-08-30 16:09:15 -06:00
|
|
|
|
2005-08-25 00:06:05 -06:00
|
|
|
pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
|
2008-05-14 11:22:03 -06:00
|
|
|
pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
|
2005-08-25 00:06:05 -06:00
|
|
|
pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
|
|
|
|
/* set file as system file if special file such
|
|
|
|
as fifo and server expecting SFU style and
|
|
|
|
no Unix extensions */
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (create_options & CREATE_OPTION_SPECIAL)
|
|
|
|
pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
|
2008-02-07 16:25:02 -07:00
|
|
|
else /* BB FIXME BB */
|
|
|
|
pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
|
2005-08-25 00:06:05 -06:00
|
|
|
|
2008-05-09 16:28:02 -06:00
|
|
|
if (create_options & CREATE_OPTION_READONLY)
|
|
|
|
pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
|
2005-08-25 00:06:05 -06:00
|
|
|
|
|
|
|
/* BB FIXME BB */
|
2007-07-12 18:33:32 -06:00
|
|
|
/* pSMB->CreateOptions = cpu_to_le32(create_options &
|
|
|
|
CREATE_OPTIONS_MASK); */
|
2005-08-25 00:06:05 -06:00
|
|
|
/* BB FIXME END BB */
|
2005-09-18 21:49:21 -06:00
|
|
|
|
|
|
|
pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
|
2005-09-22 17:32:06 -06:00
|
|
|
pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
|
2005-08-25 00:06:05 -06:00
|
|
|
count += name_len;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-08-25 00:06:05 -06:00
|
|
|
|
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
/* long_op set to 1 to allow for oplock break timeouts */
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
2011-01-11 05:24:23 -07:00
|
|
|
(struct smb_hdr *)pSMBr, &bytes_returned, 0);
|
2005-08-25 00:06:05 -06:00
|
|
|
cifs_stats_inc(&tcon->num_opens);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in Open = %d", rc);
|
2005-08-25 00:06:05 -06:00
|
|
|
} else {
|
|
|
|
/* BB verify if wct == 15 */
|
|
|
|
|
2008-05-12 22:54:12 -06:00
|
|
|
/* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
|
2005-08-25 00:06:05 -06:00
|
|
|
|
|
|
|
*netfid = pSMBr->Fid; /* cifs fid stays in le */
|
|
|
|
/* Let caller know file was created so we can set the mode. */
|
|
|
|
/* Do we care about the CreateAction in any other cases? */
|
|
|
|
/* BB FIXME BB */
|
2007-07-07 13:25:05 -06:00
|
|
|
/* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
|
2005-08-25 00:06:05 -06:00
|
|
|
*pOplock |= CIFS_CREATE_ACTION; */
|
|
|
|
/* BB FIXME END */
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (pfile_info) {
|
2005-08-25 00:06:05 -06:00
|
|
|
pfile_info->CreationTime = 0; /* BB convert CreateTime*/
|
|
|
|
pfile_info->LastAccessTime = 0; /* BB fixme */
|
|
|
|
pfile_info->LastWriteTime = 0; /* BB fixme */
|
|
|
|
pfile_info->ChangeTime = 0; /* BB fixme */
|
2005-09-22 17:32:06 -06:00
|
|
|
pfile_info->Attributes =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
|
2005-08-25 00:06:05 -06:00
|
|
|
/* the file_info buf is endian converted by caller */
|
2005-09-22 17:32:06 -06:00
|
|
|
pfile_info->AllocationSize =
|
|
|
|
cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
|
|
|
|
pfile_info->EndOfFile = pfile_info->AllocationSize;
|
2005-08-25 00:06:05 -06:00
|
|
|
pfile_info->NumberOfLinks = cpu_to_le32(1);
|
2008-10-17 19:03:20 -06:00
|
|
|
pfile_info->DeletePending = 0;
|
2005-08-25 00:06:05 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto OldOpenRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *fileName, const int openDisposition,
|
2008-02-07 16:25:02 -07:00
|
|
|
const int access_flags, const int create_options, __u16 *netfid,
|
|
|
|
int *pOplock, FILE_ALL_INFO *pfile_info,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = -EACCES;
|
|
|
|
OPEN_REQ *pSMB = NULL;
|
|
|
|
OPEN_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 count;
|
|
|
|
|
|
|
|
openRetry:
|
|
|
|
rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
count = 1; /* account for one byte pad to word boundary */
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
|
|
|
|
fileName, PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
pSMB->NameLength = cpu_to_le16(name_len);
|
2005-04-28 23:41:08 -06:00
|
|
|
} else { /* BB improve check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
count = 0; /* no pad */
|
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
pSMB->NameLength = cpu_to_le16(name_len);
|
|
|
|
strncpy(pSMB->fileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
if (*pOplock & REQ_OPLOCK)
|
|
|
|
pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
|
2007-08-30 16:09:15 -06:00
|
|
|
else if (*pOplock & REQ_BATCHOPLOCK)
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
|
|
|
|
pSMB->DesiredAccess = cpu_to_le32(access_flags);
|
|
|
|
pSMB->AllocationSize = 0;
|
2005-07-21 16:20:28 -06:00
|
|
|
/* set file as system file if special file such
|
|
|
|
as fifo and server expecting SFU style and
|
|
|
|
no Unix extensions */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (create_options & CREATE_OPTION_SPECIAL)
|
2005-07-21 16:20:28 -06:00
|
|
|
pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
|
|
|
|
else
|
|
|
|
pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
|
2008-05-09 16:28:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* XP does not handle ATTR_POSIX_SEMANTICS */
|
|
|
|
/* but it helps speed up case sensitive checks for other
|
|
|
|
servers such as Samba */
|
|
|
|
if (tcon->ses->capabilities & CAP_UNIX)
|
|
|
|
pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
|
|
|
|
|
2008-05-09 16:28:02 -06:00
|
|
|
if (create_options & CREATE_OPTION_READONLY)
|
|
|
|
pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
|
|
|
|
pSMB->CreateDisposition = cpu_to_le32(openDisposition);
|
2005-07-21 16:20:28 -06:00
|
|
|
pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
|
2005-04-28 23:41:08 -06:00
|
|
|
/* BB Expirement with various impersonation levels and verify */
|
|
|
|
pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SecurityFlags =
|
|
|
|
SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
|
|
|
|
|
|
|
|
count += name_len;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
/* long_op set to 1 to allow for oplock break timeouts */
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
2011-01-11 05:24:23 -07:00
|
|
|
(struct smb_hdr *)pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_opens);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in Open = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-04-28 23:41:08 -06:00
|
|
|
*pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
|
2005-04-16 16:20:36 -06:00
|
|
|
*netfid = pSMBr->Fid; /* cifs fid stays in le */
|
|
|
|
/* Let caller know file was created so we can set the mode. */
|
|
|
|
/* Do we care about the CreateAction in any other cases? */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
|
2007-07-12 18:33:32 -06:00
|
|
|
*pOplock |= CIFS_CREATE_ACTION;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (pfile_info) {
|
2008-12-02 17:57:54 -07:00
|
|
|
memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
|
|
|
|
36 /* CreationTime to Attributes */);
|
|
|
|
/* the file_info buf is endian converted by caller */
|
|
|
|
pfile_info->AllocationSize = pSMBr->AllocationSize;
|
|
|
|
pfile_info->EndOfFile = pSMBr->EndOfFile;
|
|
|
|
pfile_info->NumberOfLinks = cpu_to_le32(1);
|
|
|
|
pfile_info->DeletePending = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2005-08-20 22:42:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto openRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2011-10-19 13:30:07 -06:00
|
|
|
/*
|
|
|
|
* Discard any remaining data in the current SMB. To do this, we borrow the
|
|
|
|
* current bigbuf.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
|
|
|
|
{
|
2012-03-23 12:28:03 -06:00
|
|
|
unsigned int rfclen = get_rfc1002_length(server->smallbuf);
|
2011-10-19 13:30:07 -06:00
|
|
|
int remaining = rfclen + 4 - server->total_read;
|
|
|
|
struct cifs_readdata *rdata = mid->callback_data;
|
|
|
|
|
|
|
|
while (remaining > 0) {
|
|
|
|
int length;
|
|
|
|
|
|
|
|
length = cifs_read_from_socket(server, server->bigbuf,
|
|
|
|
min_t(unsigned int, remaining,
|
2012-05-17 02:45:31 -06:00
|
|
|
CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
|
2011-10-19 13:30:07 -06:00
|
|
|
if (length < 0)
|
|
|
|
return length;
|
|
|
|
server->total_read += length;
|
|
|
|
remaining -= length;
|
|
|
|
}
|
|
|
|
|
|
|
|
dequeue_mid(mid, rdata->result);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
|
|
|
|
{
|
|
|
|
int length, len;
|
2012-05-16 05:13:16 -06:00
|
|
|
unsigned int data_offset, data_len;
|
2011-10-19 13:30:07 -06:00
|
|
|
struct cifs_readdata *rdata = mid->callback_data;
|
2012-03-23 12:28:03 -06:00
|
|
|
char *buf = server->smallbuf;
|
|
|
|
unsigned int buflen = get_rfc1002_length(buf) + 4;
|
2011-10-19 13:30:07 -06:00
|
|
|
|
2012-03-23 12:28:03 -06:00
|
|
|
cFYI(1, "%s: mid=%llu offset=%llu bytes=%u", __func__,
|
2011-10-19 13:30:07 -06:00
|
|
|
mid->mid, rdata->offset, rdata->bytes);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read the rest of READ_RSP header (sans Data array), or whatever we
|
|
|
|
* can if there's not enough data. At this point, we've read down to
|
|
|
|
* the Mid.
|
|
|
|
*/
|
2012-05-17 03:02:51 -06:00
|
|
|
len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
|
2012-05-17 02:45:31 -06:00
|
|
|
HEADER_SIZE(server) + 1;
|
2011-10-19 13:30:07 -06:00
|
|
|
|
2012-05-17 02:45:31 -06:00
|
|
|
rdata->iov[0].iov_base = buf + HEADER_SIZE(server) - 1;
|
2011-10-19 13:30:07 -06:00
|
|
|
rdata->iov[0].iov_len = len;
|
|
|
|
|
|
|
|
length = cifs_readv_from_socket(server, rdata->iov, 1, len);
|
|
|
|
if (length < 0)
|
|
|
|
return length;
|
|
|
|
server->total_read += length;
|
|
|
|
|
|
|
|
/* Was the SMB read successful? */
|
2012-05-17 03:02:51 -06:00
|
|
|
rdata->result = server->ops->map_error(buf, false);
|
2011-10-19 13:30:07 -06:00
|
|
|
if (rdata->result != 0) {
|
|
|
|
cFYI(1, "%s: server returned error %d", __func__,
|
|
|
|
rdata->result);
|
|
|
|
return cifs_readv_discard(server, mid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is there enough to get to the rest of the READ_RSP header? */
|
2012-05-17 03:02:51 -06:00
|
|
|
if (server->total_read < server->vals->read_rsp_size) {
|
2011-10-19 13:30:07 -06:00
|
|
|
cFYI(1, "%s: server returned short header. got=%u expected=%zu",
|
2012-05-17 03:02:51 -06:00
|
|
|
__func__, server->total_read,
|
|
|
|
server->vals->read_rsp_size);
|
2011-10-19 13:30:07 -06:00
|
|
|
rdata->result = -EIO;
|
|
|
|
return cifs_readv_discard(server, mid);
|
|
|
|
}
|
|
|
|
|
2012-05-17 03:02:51 -06:00
|
|
|
data_offset = server->ops->read_data_offset(buf) + 4;
|
2011-10-19 13:30:07 -06:00
|
|
|
if (data_offset < server->total_read) {
|
|
|
|
/*
|
|
|
|
* win2k8 sometimes sends an offset of 0 when the read
|
|
|
|
* is beyond the EOF. Treat it as if the data starts just after
|
|
|
|
* the header.
|
|
|
|
*/
|
|
|
|
cFYI(1, "%s: data offset (%u) inside read response header",
|
|
|
|
__func__, data_offset);
|
|
|
|
data_offset = server->total_read;
|
|
|
|
} else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
|
|
|
|
/* data_offset is beyond the end of smallbuf */
|
|
|
|
cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
|
|
|
|
__func__, data_offset);
|
|
|
|
rdata->result = -EIO;
|
|
|
|
return cifs_readv_discard(server, mid);
|
|
|
|
}
|
|
|
|
|
|
|
|
cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
|
|
|
|
server->total_read, data_offset);
|
|
|
|
|
|
|
|
len = data_offset - server->total_read;
|
|
|
|
if (len > 0) {
|
|
|
|
/* read any junk before data into the rest of smallbuf */
|
2012-03-23 12:28:03 -06:00
|
|
|
rdata->iov[0].iov_base = buf + server->total_read;
|
2011-10-19 13:30:07 -06:00
|
|
|
rdata->iov[0].iov_len = len;
|
|
|
|
length = cifs_readv_from_socket(server, rdata->iov, 1, len);
|
|
|
|
if (length < 0)
|
|
|
|
return length;
|
|
|
|
server->total_read += length;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set up first iov for signature check */
|
2012-03-23 12:28:03 -06:00
|
|
|
rdata->iov[0].iov_base = buf;
|
2011-10-19 13:30:07 -06:00
|
|
|
rdata->iov[0].iov_len = server->total_read;
|
|
|
|
cFYI(1, "0: iov_base=%p iov_len=%zu",
|
|
|
|
rdata->iov[0].iov_base, rdata->iov[0].iov_len);
|
|
|
|
|
|
|
|
/* how much data is in the response? */
|
2012-05-17 03:02:51 -06:00
|
|
|
data_len = server->ops->read_data_length(buf);
|
2012-03-23 12:28:03 -06:00
|
|
|
if (data_offset + data_len > buflen) {
|
2011-10-19 13:30:07 -06:00
|
|
|
/* data_len is corrupt -- discard frame */
|
|
|
|
rdata->result = -EIO;
|
|
|
|
return cifs_readv_discard(server, mid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* marshal up the page array */
|
2012-07-11 07:09:36 -06:00
|
|
|
cifs_kmap_lock();
|
2012-05-16 05:13:16 -06:00
|
|
|
len = rdata->marshal_iov(rdata, data_len);
|
2012-07-11 07:09:36 -06:00
|
|
|
cifs_kmap_unlock();
|
2012-05-16 05:13:16 -06:00
|
|
|
data_len -= len;
|
2011-10-19 13:30:07 -06:00
|
|
|
|
|
|
|
/* issue the read if we have any iovecs left to fill */
|
|
|
|
if (rdata->nr_iov > 1) {
|
|
|
|
length = cifs_readv_from_socket(server, &rdata->iov[1],
|
|
|
|
rdata->nr_iov - 1, len);
|
|
|
|
if (length < 0)
|
|
|
|
return length;
|
|
|
|
server->total_read += length;
|
|
|
|
} else {
|
|
|
|
length = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdata->bytes = length;
|
|
|
|
|
2012-03-23 12:28:03 -06:00
|
|
|
cFYI(1, "total_read=%u buflen=%u remaining=%u", server->total_read,
|
2012-05-16 05:13:16 -06:00
|
|
|
buflen, data_len);
|
2011-10-19 13:30:07 -06:00
|
|
|
|
|
|
|
/* discard anything left over */
|
2012-03-23 12:28:03 -06:00
|
|
|
if (server->total_read < buflen)
|
2011-10-19 13:30:07 -06:00
|
|
|
return cifs_readv_discard(server, mid);
|
|
|
|
|
|
|
|
dequeue_mid(mid, false);
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cifs_readv_callback(struct mid_q_entry *mid)
|
|
|
|
{
|
|
|
|
struct cifs_readdata *rdata = mid->callback_data;
|
|
|
|
struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
|
|
|
|
struct TCP_Server_Info *server = tcon->ses->server;
|
|
|
|
|
2012-03-23 12:28:03 -06:00
|
|
|
cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
|
|
|
|
mid->mid, mid->mid_state, rdata->result, rdata->bytes);
|
2011-10-19 13:30:07 -06:00
|
|
|
|
2012-03-23 12:28:03 -06:00
|
|
|
switch (mid->mid_state) {
|
2011-10-19 13:30:07 -06:00
|
|
|
case MID_RESPONSE_RECEIVED:
|
|
|
|
/* result already set, check signature */
|
|
|
|
if (server->sec_mode &
|
|
|
|
(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
|
|
|
|
if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
|
|
|
|
server, mid->sequence_number + 1))
|
|
|
|
cERROR(1, "Unexpected SMB signature");
|
|
|
|
}
|
|
|
|
/* FIXME: should this be counted toward the initiating task? */
|
|
|
|
task_io_account_read(rdata->bytes);
|
|
|
|
cifs_stats_bytes_read(tcon, rdata->bytes);
|
|
|
|
break;
|
|
|
|
case MID_REQUEST_SUBMITTED:
|
|
|
|
case MID_RETRY_NEEDED:
|
|
|
|
rdata->result = -EAGAIN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
rdata->result = -EIO;
|
|
|
|
}
|
|
|
|
|
2012-03-23 12:40:53 -06:00
|
|
|
queue_work(cifsiod_wq, &rdata->work);
|
2011-10-19 13:30:07 -06:00
|
|
|
DeleteMidQEntry(mid);
|
2012-05-17 07:53:29 -06:00
|
|
|
add_credits(server, 1);
|
2011-10-19 13:30:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* cifs_async_readv - send an async write, and set up mid to handle result */
|
|
|
|
int
|
|
|
|
cifs_async_readv(struct cifs_readdata *rdata)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
READ_REQ *smb = NULL;
|
|
|
|
int wct;
|
|
|
|
struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
|
|
|
|
|
|
|
|
cFYI(1, "%s: offset=%llu bytes=%u", __func__,
|
|
|
|
rdata->offset, rdata->bytes);
|
|
|
|
|
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_FILES)
|
|
|
|
wct = 12;
|
|
|
|
else {
|
|
|
|
wct = 10; /* old style read */
|
|
|
|
if ((rdata->offset >> 32) > 0) {
|
|
|
|
/* can not handle this big offset for old */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
|
|
|
|
smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
|
|
|
|
|
|
|
|
smb->AndXCommand = 0xFF; /* none */
|
|
|
|
smb->Fid = rdata->cfile->netfid;
|
|
|
|
smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
|
|
|
|
if (wct == 12)
|
|
|
|
smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
|
|
|
|
smb->Remaining = 0;
|
|
|
|
smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
|
|
|
|
smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
|
|
|
|
if (wct == 12)
|
|
|
|
smb->ByteCount = 0;
|
|
|
|
else {
|
|
|
|
/* old style read */
|
|
|
|
struct smb_com_readx_req *smbr =
|
|
|
|
(struct smb_com_readx_req *)smb;
|
|
|
|
smbr->ByteCount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 4 for RFC1001 length + 1 for BCC */
|
|
|
|
rdata->iov[0].iov_base = smb;
|
|
|
|
rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
|
|
|
|
|
2012-05-16 05:13:17 -06:00
|
|
|
kref_get(&rdata->refcount);
|
2011-10-19 13:30:07 -06:00
|
|
|
rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
|
|
|
|
cifs_readv_receive, cifs_readv_callback,
|
|
|
|
rdata, false);
|
|
|
|
|
|
|
|
if (rc == 0)
|
|
|
|
cifs_stats_inc(&tcon->num_reads);
|
2012-05-16 05:13:17 -06:00
|
|
|
else
|
|
|
|
kref_put(&rdata->refcount, cifs_readdata_release);
|
2011-10-19 13:30:07 -06:00
|
|
|
|
|
|
|
cifs_small_buf_release(smb);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 00:02:00 -06:00
|
|
|
CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
|
2007-07-12 18:33:32 -06:00
|
|
|
char **buf, int *pbuf_type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = -EACCES;
|
|
|
|
READ_REQ *pSMB = NULL;
|
|
|
|
READ_RSP *pSMBr = NULL;
|
|
|
|
char *pReadData = NULL;
|
2005-08-31 22:50:37 -06:00
|
|
|
int wct;
|
2005-12-12 21:53:18 -07:00
|
|
|
int resp_buf_type = 0;
|
|
|
|
struct kvec iov[1];
|
2011-05-26 00:02:00 -06:00
|
|
|
__u32 pid = io_parms->pid;
|
|
|
|
__u16 netfid = io_parms->netfid;
|
|
|
|
__u64 offset = io_parms->offset;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_tcon *tcon = io_parms->tcon;
|
2011-05-26 00:02:00 -06:00
|
|
|
unsigned int count = io_parms->length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Reading %d bytes on fid %d", count, netfid);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_FILES)
|
2005-08-31 22:50:37 -06:00
|
|
|
wct = 12;
|
2008-12-08 17:28:16 -07:00
|
|
|
else {
|
2005-08-31 22:50:37 -06:00
|
|
|
wct = 10; /* old style read */
|
2011-05-26 00:02:00 -06:00
|
|
|
if ((offset >> 32) > 0) {
|
2008-12-08 17:28:16 -07:00
|
|
|
/* can not handle this big offset for old */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*nbytes = 0;
|
2005-12-12 21:53:18 -07:00
|
|
|
rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2011-05-26 00:02:00 -06:00
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* tcon and ses pointer are checked in smb_init */
|
|
|
|
if (tcon->ses->server == NULL)
|
|
|
|
return -ECONNABORTED;
|
|
|
|
|
2005-12-12 21:53:18 -07:00
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Fid = netfid;
|
2011-05-26 00:02:00 -06:00
|
|
|
pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 12)
|
2011-05-26 00:02:00 -06:00
|
|
|
pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
|
2005-08-31 22:50:37 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Remaining = 0;
|
|
|
|
pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
|
|
|
|
pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 12)
|
2005-08-31 22:50:37 -06:00
|
|
|
pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
|
|
|
|
else {
|
|
|
|
/* old style read */
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_readx_req *pSMBW =
|
2005-08-31 22:50:37 -06:00
|
|
|
(struct smb_com_readx_req *)pSMB;
|
2005-12-12 21:53:18 -07:00
|
|
|
pSMBW->ByteCount = 0;
|
2005-08-31 22:50:37 -06:00
|
|
|
}
|
2005-12-12 21:53:18 -07:00
|
|
|
|
|
|
|
iov[0].iov_base = (char *)pSMB;
|
2011-04-28 23:40:20 -06:00
|
|
|
iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
|
2007-10-18 15:45:27 -06:00
|
|
|
rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
|
2011-01-11 05:24:23 -07:00
|
|
|
&resp_buf_type, CIFS_LOG_ERROR);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_reads);
|
2005-12-12 21:53:18 -07:00
|
|
|
pSMBr = (READ_RSP *)iov[0].iov_base;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in read = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
|
|
|
|
data_length = data_length << 16;
|
|
|
|
data_length += le16_to_cpu(pSMBr->DataLength);
|
|
|
|
*nbytes = data_length;
|
|
|
|
|
|
|
|
/*check that DataLength would not go beyond end of SMB */
|
2005-12-12 21:53:18 -07:00
|
|
|
if ((data_length > CIFSMaxBufSize)
|
2005-04-16 16:20:36 -06:00
|
|
|
|| (data_length > count)) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "bad length %d for count %d",
|
|
|
|
data_length, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO;
|
|
|
|
*nbytes = 0;
|
|
|
|
} else {
|
2005-12-12 21:53:18 -07:00
|
|
|
pReadData = (char *) (&pSMBr->hdr.Protocol) +
|
2007-08-30 16:09:15 -06:00
|
|
|
le16_to_cpu(pSMBr->DataOffset);
|
|
|
|
/* if (rc = copy_to_user(buf, pReadData, data_length)) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Faulting on read rc = %d",rc);
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = -EFAULT;
|
2007-08-30 16:09:15 -06:00
|
|
|
}*/ /* can not use copy_to_user when using page cache*/
|
2007-07-07 13:25:05 -06:00
|
|
|
if (*buf)
|
2007-07-12 18:33:32 -06:00
|
|
|
memcpy(*buf, pReadData, data_length);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-26 09:41:18 -07:00
|
|
|
/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (*buf) {
|
|
|
|
if (resp_buf_type == CIFS_SMALL_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
cifs_small_buf_release(iov[0].iov_base);
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (resp_buf_type == CIFS_LARGE_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
cifs_buf_release(iov[0].iov_base);
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (resp_buf_type != CIFS_NO_BUFFER) {
|
2007-07-12 18:33:32 -06:00
|
|
|
/* return buffer to caller to free */
|
|
|
|
*buf = iov[0].iov_base;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (resp_buf_type == CIFS_SMALL_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
*pbuf_type = CIFS_SMALL_BUFFER;
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (resp_buf_type == CIFS_LARGE_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
*pbuf_type = CIFS_LARGE_BUFFER;
|
2006-02-22 16:31:52 -07:00
|
|
|
} /* else no valid buffer on return - leave as null */
|
2005-12-12 21:53:18 -07:00
|
|
|
|
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-12-12 21:53:18 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 00:01:59 -06:00
|
|
|
CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
|
|
|
|
unsigned int *nbytes, const char *buf,
|
2007-07-12 18:33:32 -06:00
|
|
|
const char __user *ubuf, const int long_op)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = -EACCES;
|
|
|
|
WRITE_REQ *pSMB = NULL;
|
|
|
|
WRITE_RSP *pSMBr = NULL;
|
2005-08-30 21:58:07 -06:00
|
|
|
int bytes_returned, wct;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u32 bytes_sent;
|
|
|
|
__u16 byte_count;
|
2011-05-26 00:01:59 -06:00
|
|
|
__u32 pid = io_parms->pid;
|
|
|
|
__u16 netfid = io_parms->netfid;
|
|
|
|
__u64 offset = io_parms->offset;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_tcon *tcon = io_parms->tcon;
|
2011-05-26 00:01:59 -06:00
|
|
|
unsigned int count = io_parms->length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-03 11:20:21 -06:00
|
|
|
*nbytes = 0;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
/* cFYI(1, "write at %lld %d bytes", offset, count);*/
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon->ses == NULL)
|
2005-08-30 21:58:07 -06:00
|
|
|
return -ECONNABORTED;
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_FILES)
|
2005-08-30 21:58:07 -06:00
|
|
|
wct = 14;
|
2008-12-08 17:28:16 -07:00
|
|
|
else {
|
2005-08-30 21:58:07 -06:00
|
|
|
wct = 12;
|
2008-12-08 17:28:16 -07:00
|
|
|
if ((offset >> 32) > 0) {
|
|
|
|
/* can not handle big offset for old srv */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
2005-08-30 21:58:07 -06:00
|
|
|
|
|
|
|
rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
|
2005-04-16 16:20:36 -06:00
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2011-05-26 00:01:59 -06:00
|
|
|
|
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* tcon and ses pointer are checked in smb_init */
|
|
|
|
if (tcon->ses->server == NULL)
|
|
|
|
return -ECONNABORTED;
|
|
|
|
|
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
|
|
|
pSMB->Fid = netfid;
|
|
|
|
pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-08-30 21:58:07 -06:00
|
|
|
pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Reserved = 0xFFFFFFFF;
|
|
|
|
pSMB->WriteMode = 0;
|
|
|
|
pSMB->Remaining = 0;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Can increase buffer size if buffer is big enough in some cases ie we
|
2005-04-16 16:20:36 -06:00
|
|
|
can send more if LARGE_WRITE_X capability returned by the server and if
|
|
|
|
our buffer is big enough or if we convert to iovecs on socket writes
|
|
|
|
and eliminate the copy to the CIFS buffer */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
|
2005-04-16 16:20:36 -06:00
|
|
|
bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
|
|
|
|
} else {
|
|
|
|
bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
|
|
|
|
& ~0xFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bytes_sent > count)
|
|
|
|
bytes_sent = count;
|
|
|
|
pSMB->DataOffset =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (buf)
|
2008-12-02 17:57:54 -07:00
|
|
|
memcpy(pSMB->Data, buf, bytes_sent);
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (ubuf) {
|
|
|
|
if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2005-09-20 21:49:16 -06:00
|
|
|
} else if (count != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* No buffer */
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
return -EINVAL;
|
2005-09-20 21:49:16 -06:00
|
|
|
} /* else setting file size with write of zero bytes */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-09-20 21:49:16 -06:00
|
|
|
byte_count = bytes_sent + 1; /* pad */
|
2008-02-07 16:25:02 -07:00
|
|
|
else /* wct == 12 */
|
2005-09-20 21:49:16 -06:00
|
|
|
byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
|
2008-02-07 16:25:02 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
|
|
|
|
pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-08-30 21:58:07 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-08-30 21:58:07 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
2007-07-12 18:33:32 -06:00
|
|
|
else { /* old style write has byte count 4 bytes earlier
|
|
|
|
so 4 bytes pad */
|
|
|
|
struct smb_com_writex_req *pSMBW =
|
2005-08-30 21:58:07 -06:00
|
|
|
(struct smb_com_writex_req *)pSMB;
|
|
|
|
pSMBW->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, long_op);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_writes);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 22:12:10 -06:00
|
|
|
cFYI(1, "Send error in write = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
*nbytes = le16_to_cpu(pSMBr->CountHigh);
|
|
|
|
*nbytes = (*nbytes) << 16;
|
|
|
|
*nbytes += le16_to_cpu(pSMBr->Count);
|
2010-03-31 00:30:03 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Mask off high 16 bits when bytes written as returned by the
|
|
|
|
* server is greater than bytes requested by the client. Some
|
|
|
|
* OS/2 servers are known to set incorrect CountHigh values.
|
|
|
|
*/
|
|
|
|
if (*nbytes > count)
|
|
|
|
*nbytes &= 0xFFFF;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2011-05-19 14:22:56 -06:00
|
|
|
void
|
|
|
|
cifs_writedata_release(struct kref *refcount)
|
|
|
|
{
|
|
|
|
struct cifs_writedata *wdata = container_of(refcount,
|
|
|
|
struct cifs_writedata, refcount);
|
|
|
|
|
|
|
|
if (wdata->cfile)
|
|
|
|
cifsFileInfo_put(wdata->cfile);
|
|
|
|
|
|
|
|
kfree(wdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write failed with a retryable error. Resend the write request. It's also
|
|
|
|
* possible that the page was redirtied so re-clean the page.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
cifs_writev_requeue(struct cifs_writedata *wdata)
|
|
|
|
{
|
|
|
|
int i, rc;
|
|
|
|
struct inode *inode = wdata->cfile->dentry->d_inode;
|
|
|
|
|
|
|
|
for (i = 0; i < wdata->nr_pages; i++) {
|
|
|
|
lock_page(wdata->pages[i]);
|
|
|
|
clear_page_dirty_for_io(wdata->pages[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
rc = cifs_async_writev(wdata);
|
|
|
|
} while (rc == -EAGAIN);
|
|
|
|
|
|
|
|
for (i = 0; i < wdata->nr_pages; i++) {
|
|
|
|
if (rc != 0)
|
|
|
|
SetPageError(wdata->pages[i]);
|
|
|
|
unlock_page(wdata->pages[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
mapping_set_error(inode->i_mapping, rc);
|
|
|
|
kref_put(&wdata->refcount, cifs_writedata_release);
|
|
|
|
}
|
|
|
|
|
2012-03-23 12:40:55 -06:00
|
|
|
void
|
2011-05-19 14:22:56 -06:00
|
|
|
cifs_writev_complete(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct cifs_writedata *wdata = container_of(work,
|
|
|
|
struct cifs_writedata, work);
|
|
|
|
struct inode *inode = wdata->cfile->dentry->d_inode;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
if (wdata->result == 0) {
|
2012-03-23 12:40:56 -06:00
|
|
|
spin_lock(&inode->i_lock);
|
2011-05-19 14:22:56 -06:00
|
|
|
cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
|
2012-03-23 12:40:56 -06:00
|
|
|
spin_unlock(&inode->i_lock);
|
2011-05-19 14:22:56 -06:00
|
|
|
cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
|
|
|
|
wdata->bytes);
|
|
|
|
} else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
|
|
|
|
return cifs_writev_requeue(wdata);
|
|
|
|
|
|
|
|
for (i = 0; i < wdata->nr_pages; i++) {
|
|
|
|
struct page *page = wdata->pages[i];
|
|
|
|
if (wdata->result == -EAGAIN)
|
|
|
|
__set_page_dirty_nobuffers(page);
|
|
|
|
else if (wdata->result < 0)
|
|
|
|
SetPageError(page);
|
|
|
|
end_page_writeback(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
if (wdata->result != -EAGAIN)
|
|
|
|
mapping_set_error(inode->i_mapping, wdata->result);
|
|
|
|
kref_put(&wdata->refcount, cifs_writedata_release);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct cifs_writedata *
|
2012-03-23 12:40:55 -06:00
|
|
|
cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
|
2011-05-19 14:22:56 -06:00
|
|
|
{
|
|
|
|
struct cifs_writedata *wdata;
|
|
|
|
|
|
|
|
/* this would overflow */
|
|
|
|
if (nr_pages == 0) {
|
|
|
|
cERROR(1, "%s: called with nr_pages == 0!", __func__);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* writedata + number of page pointers */
|
|
|
|
wdata = kzalloc(sizeof(*wdata) +
|
|
|
|
sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
|
|
|
|
if (wdata != NULL) {
|
|
|
|
kref_init(&wdata->refcount);
|
2012-03-23 12:40:56 -06:00
|
|
|
INIT_LIST_HEAD(&wdata->list);
|
|
|
|
init_completion(&wdata->done);
|
|
|
|
INIT_WORK(&wdata->work, complete);
|
2011-05-19 14:22:56 -06:00
|
|
|
}
|
|
|
|
return wdata;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-03-23 12:28:03 -06:00
|
|
|
* Check the mid_state and signature on received buffer (if any), and queue the
|
2011-05-19 14:22:56 -06:00
|
|
|
* workqueue completion task.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
cifs_writev_callback(struct mid_q_entry *mid)
|
|
|
|
{
|
|
|
|
struct cifs_writedata *wdata = mid->callback_data;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
|
2011-05-19 14:22:56 -06:00
|
|
|
unsigned int written;
|
|
|
|
WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
|
|
|
|
|
2012-03-23 12:28:03 -06:00
|
|
|
switch (mid->mid_state) {
|
2011-05-19 14:22:56 -06:00
|
|
|
case MID_RESPONSE_RECEIVED:
|
|
|
|
wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
|
|
|
|
if (wdata->result != 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
written = le16_to_cpu(smb->CountHigh);
|
|
|
|
written <<= 16;
|
|
|
|
written += le16_to_cpu(smb->Count);
|
|
|
|
/*
|
|
|
|
* Mask off high 16 bits when bytes written as returned
|
|
|
|
* by the server is greater than bytes requested by the
|
|
|
|
* client. OS/2 servers are known to set incorrect
|
|
|
|
* CountHigh values.
|
|
|
|
*/
|
|
|
|
if (written > wdata->bytes)
|
|
|
|
written &= 0xFFFF;
|
|
|
|
|
|
|
|
if (written < wdata->bytes)
|
|
|
|
wdata->result = -ENOSPC;
|
|
|
|
else
|
|
|
|
wdata->bytes = written;
|
|
|
|
break;
|
|
|
|
case MID_REQUEST_SUBMITTED:
|
|
|
|
case MID_RETRY_NEEDED:
|
|
|
|
wdata->result = -EAGAIN;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
wdata->result = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-03-23 12:40:53 -06:00
|
|
|
queue_work(cifsiod_wq, &wdata->work);
|
2011-05-19 14:22:56 -06:00
|
|
|
DeleteMidQEntry(mid);
|
2012-05-17 07:53:29 -06:00
|
|
|
add_credits(tcon->ses->server, 1);
|
2011-05-19 14:22:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* cifs_async_writev - send an async write, and set up mid to handle result */
|
|
|
|
int
|
|
|
|
cifs_async_writev(struct cifs_writedata *wdata)
|
|
|
|
{
|
|
|
|
int i, rc = -EACCES;
|
|
|
|
WRITE_REQ *smb = NULL;
|
|
|
|
int wct;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
|
2011-05-19 14:22:56 -06:00
|
|
|
struct kvec *iov = NULL;
|
|
|
|
|
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_FILES) {
|
|
|
|
wct = 14;
|
|
|
|
} else {
|
|
|
|
wct = 12;
|
|
|
|
if (wdata->offset >> 32 > 0) {
|
|
|
|
/* can not handle big offset for old srv */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
|
|
|
|
if (rc)
|
|
|
|
goto async_writev_out;
|
|
|
|
|
|
|
|
/* 1 iov per page + 1 for header */
|
|
|
|
iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
|
|
|
|
if (iov == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto async_writev_out;
|
|
|
|
}
|
|
|
|
|
2012-03-23 12:40:55 -06:00
|
|
|
smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
|
|
|
|
smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
|
2011-05-26 00:01:59 -06:00
|
|
|
|
2011-05-19 14:22:56 -06:00
|
|
|
smb->AndXCommand = 0xFF; /* none */
|
|
|
|
smb->Fid = wdata->cfile->netfid;
|
|
|
|
smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
|
|
|
|
if (wct == 14)
|
|
|
|
smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
|
|
|
|
smb->Reserved = 0xFFFFFFFF;
|
|
|
|
smb->WriteMode = 0;
|
|
|
|
smb->Remaining = 0;
|
|
|
|
|
|
|
|
smb->DataOffset =
|
|
|
|
cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
|
|
|
|
|
|
|
|
/* 4 for RFC1001 length + 1 for BCC */
|
|
|
|
iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
|
|
|
|
iov[0].iov_base = smb;
|
|
|
|
|
2012-03-23 12:40:56 -06:00
|
|
|
/*
|
|
|
|
* This function should marshal up the page array into the kvec
|
|
|
|
* array, reserving [0] for the header. It should kmap the pages
|
|
|
|
* and set the iov_len properly for each one. It may also set
|
|
|
|
* wdata->bytes too.
|
|
|
|
*/
|
2012-07-11 07:09:36 -06:00
|
|
|
cifs_kmap_lock();
|
2012-03-23 12:40:56 -06:00
|
|
|
wdata->marshal_iov(iov, wdata);
|
2012-07-11 07:09:36 -06:00
|
|
|
cifs_kmap_unlock();
|
2011-05-19 14:22:56 -06:00
|
|
|
|
|
|
|
cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
|
|
|
|
|
|
|
|
smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
|
|
|
|
smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
|
|
|
|
|
|
|
|
if (wct == 14) {
|
|
|
|
inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
|
|
|
|
put_bcc(wdata->bytes + 1, &smb->hdr);
|
|
|
|
} else {
|
|
|
|
/* wct == 12 */
|
|
|
|
struct smb_com_writex_req *smbw =
|
|
|
|
(struct smb_com_writex_req *)smb;
|
|
|
|
inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
|
|
|
|
put_bcc(wdata->bytes + 5, &smbw->hdr);
|
|
|
|
iov[0].iov_len += 4; /* pad bigger by four bytes */
|
|
|
|
}
|
|
|
|
|
|
|
|
kref_get(&wdata->refcount);
|
|
|
|
rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
|
2011-10-19 13:29:49 -06:00
|
|
|
NULL, cifs_writev_callback, wdata, false);
|
2011-05-19 14:22:56 -06:00
|
|
|
|
|
|
|
if (rc == 0)
|
|
|
|
cifs_stats_inc(&tcon->num_writes);
|
|
|
|
else
|
|
|
|
kref_put(&wdata->refcount, cifs_writedata_release);
|
|
|
|
|
|
|
|
/* send is done, unmap pages */
|
|
|
|
for (i = 0; i < wdata->nr_pages; i++)
|
|
|
|
kunmap(wdata->pages[i]);
|
|
|
|
|
|
|
|
async_writev_out:
|
|
|
|
cifs_small_buf_release(smb);
|
|
|
|
kfree(iov);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-06-13 12:24:43 -06:00
|
|
|
int
|
2011-05-26 00:01:59 -06:00
|
|
|
CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
|
|
|
|
unsigned int *nbytes, struct kvec *iov, int n_vec,
|
|
|
|
const int long_op)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = -EACCES;
|
|
|
|
WRITE_REQ *pSMB = NULL;
|
2005-12-12 21:53:18 -07:00
|
|
|
int wct;
|
2005-06-13 12:24:43 -06:00
|
|
|
int smb_hdr_len;
|
2005-12-12 21:53:18 -07:00
|
|
|
int resp_buf_type = 0;
|
2011-05-26 00:01:59 -06:00
|
|
|
__u32 pid = io_parms->pid;
|
|
|
|
__u16 netfid = io_parms->netfid;
|
|
|
|
__u64 offset = io_parms->offset;
|
2011-05-26 22:34:02 -06:00
|
|
|
struct cifs_tcon *tcon = io_parms->tcon;
|
2011-05-26 00:01:59 -06:00
|
|
|
unsigned int count = io_parms->length;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-03 11:44:00 -06:00
|
|
|
*nbytes = 0;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
|
2005-11-15 17:45:16 -07:00
|
|
|
|
2008-12-08 17:28:16 -07:00
|
|
|
if (tcon->ses->capabilities & CAP_LARGE_FILES) {
|
2005-10-03 14:49:43 -06:00
|
|
|
wct = 14;
|
2008-12-08 17:28:16 -07:00
|
|
|
} else {
|
2005-10-03 14:49:43 -06:00
|
|
|
wct = 12;
|
2008-12-08 17:28:16 -07:00
|
|
|
if ((offset >> 32) > 0) {
|
|
|
|
/* can not handle big offset for old srv */
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
}
|
2005-10-03 14:49:43 -06:00
|
|
|
rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
2011-05-26 00:01:59 -06:00
|
|
|
|
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* tcon and ses pointer are checked in smb_init */
|
|
|
|
if (tcon->ses->server == NULL)
|
|
|
|
return -ECONNABORTED;
|
|
|
|
|
2005-06-13 12:24:43 -06:00
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Fid = netfid;
|
|
|
|
pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-10-03 14:49:43 -06:00
|
|
|
pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Reserved = 0xFFFFFFFF;
|
|
|
|
pSMB->WriteMode = 0;
|
|
|
|
pSMB->Remaining = 0;
|
2005-06-13 12:24:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataOffset =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-10-03 14:37:24 -06:00
|
|
|
pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
|
|
|
|
pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
|
2011-04-28 23:40:20 -06:00
|
|
|
/* header + 1 byte pad */
|
|
|
|
smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count + 1);
|
2005-10-03 14:49:43 -06:00
|
|
|
else /* wct == 12 */
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-10-03 14:49:43 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count + 1);
|
|
|
|
else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_writex_req *pSMBW =
|
2005-10-03 14:49:43 -06:00
|
|
|
(struct smb_com_writex_req *)pSMB;
|
|
|
|
pSMBW->ByteCount = cpu_to_le16(count + 5);
|
|
|
|
}
|
2005-10-03 14:37:24 -06:00
|
|
|
iov[0].iov_base = pSMB;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (wct == 14)
|
2005-12-12 21:53:18 -07:00
|
|
|
iov[0].iov_len = smb_hdr_len + 4;
|
|
|
|
else /* wct == 12 pad bigger by four bytes */
|
|
|
|
iov[0].iov_len = smb_hdr_len + 8;
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-12-12 21:53:18 -07:00
|
|
|
rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
|
2007-11-13 15:41:37 -07:00
|
|
|
long_op);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_writes);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error Write2 = %d", rc);
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (resp_buf_type == 0) {
|
2005-12-12 21:53:18 -07:00
|
|
|
/* presumably this can not happen, but best to be safe */
|
|
|
|
rc = -EIO;
|
2005-06-13 12:24:43 -06:00
|
|
|
} else {
|
2008-02-07 16:25:02 -07:00
|
|
|
WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
|
2005-06-13 12:24:43 -06:00
|
|
|
*nbytes = le16_to_cpu(pSMBr->CountHigh);
|
|
|
|
*nbytes = (*nbytes) << 16;
|
|
|
|
*nbytes += le16_to_cpu(pSMBr->Count);
|
2010-03-31 00:30:03 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Mask off high 16 bits when bytes written as returned by the
|
|
|
|
* server is greater than bytes requested by the client. OS/2
|
|
|
|
* servers are known to set incorrect CountHigh values.
|
|
|
|
*/
|
|
|
|
if (*nbytes > count)
|
|
|
|
*nbytes &= 0xFFFF;
|
2007-07-12 18:33:32 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-02-26 09:41:18 -07:00
|
|
|
/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (resp_buf_type == CIFS_SMALL_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
cifs_small_buf_release(iov[0].iov_base);
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (resp_buf_type == CIFS_LARGE_BUFFER)
|
2005-12-12 21:53:18 -07:00
|
|
|
cifs_buf_release(iov[0].iov_base);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2005-06-13 12:24:43 -06:00
|
|
|
|
2011-10-22 05:33:31 -06:00
|
|
|
int cifs_lockv(const int xid, struct cifs_tcon *tcon, const __u16 netfid,
|
|
|
|
const __u8 lock_type, const __u32 num_unlock,
|
|
|
|
const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
LOCK_REQ *pSMB = NULL;
|
|
|
|
struct kvec iov[2];
|
|
|
|
int resp_buf_type;
|
|
|
|
__u16 count;
|
|
|
|
|
|
|
|
cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
|
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->NumberOfLocks = cpu_to_le16(num_lock);
|
|
|
|
pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
|
|
|
|
pSMB->LockType = lock_type;
|
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
|
|
|
pSMB->Fid = netfid; /* netfid stays le */
|
|
|
|
|
|
|
|
count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
|
|
|
|
inc_rfc1001_len(pSMB, count);
|
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
|
|
|
iov[0].iov_base = (char *)pSMB;
|
|
|
|
iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
|
|
|
|
(num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
|
|
|
|
iov[1].iov_base = (char *)buf;
|
|
|
|
iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
|
|
|
|
|
|
|
|
cifs_stats_inc(&tcon->num_locks);
|
|
|
|
rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
|
|
|
|
if (rc)
|
|
|
|
cFYI(1, "Send error in cifs_lockv = %d", rc);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2005-06-13 12:24:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
|
2010-08-17 01:26:00 -06:00
|
|
|
const __u16 smb_file_id, const __u32 netpid, const __u64 len,
|
2005-04-16 16:20:36 -06:00
|
|
|
const __u64 offset, const __u32 numUnlock,
|
2011-01-17 10:15:44 -07:00
|
|
|
const __u32 numLock, const __u8 lockType,
|
|
|
|
const bool waitFlag, const __u8 oplock_level)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
LOCK_REQ *pSMB = NULL;
|
2008-05-23 11:38:32 -06:00
|
|
|
/* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
|
2005-04-16 16:20:36 -06:00
|
|
|
int bytes_returned;
|
|
|
|
int timeout = 0;
|
|
|
|
__u16 count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
|
2005-04-28 23:41:09 -06:00
|
|
|
rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
|
2007-11-13 15:41:37 -07:00
|
|
|
timeout = CIFS_ASYNC_OP; /* no response expected */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Timeout = 0;
|
2008-04-28 18:06:05 -06:00
|
|
|
} else if (waitFlag) {
|
2007-11-13 15:41:37 -07:00
|
|
|
timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
|
|
|
|
} else {
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pSMB->NumberOfLocks = cpu_to_le16(numLock);
|
|
|
|
pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
|
|
|
|
pSMB->LockType = lockType;
|
2011-01-17 10:15:44 -07:00
|
|
|
pSMB->OplockLevel = oplock_level;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->AndXCommand = 0xFF; /* none */
|
|
|
|
pSMB->Fid = smb_file_id; /* netfid stays le */
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((numLock != 0) || (numUnlock != 0)) {
|
2010-08-17 01:26:00 -06:00
|
|
|
pSMB->Locks[0].Pid = cpu_to_le16(netpid);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* BB where to store pid high? */
|
|
|
|
pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
|
|
|
|
pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
|
|
|
|
pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
|
|
|
|
pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
|
|
|
|
count = sizeof(LOCKING_ANDX_RANGE);
|
|
|
|
} else {
|
|
|
|
/* oplock break */
|
|
|
|
count = 0;
|
|
|
|
}
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
2006-08-02 15:56:33 -06:00
|
|
|
if (waitFlag) {
|
|
|
|
rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
|
2008-05-23 11:38:32 -06:00
|
|
|
(struct smb_hdr *) pSMB, &bytes_returned);
|
2007-11-13 15:41:37 -07:00
|
|
|
cifs_small_buf_release(pSMB);
|
2006-08-02 15:56:33 -06:00
|
|
|
} else {
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, timeout);
|
2007-11-13 15:41:37 -07:00
|
|
|
/* SMB buffer freed by function above */
|
2006-08-02 15:56:33 -06:00
|
|
|
}
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_locks);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Lock = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2006-02-28 15:39:25 -07:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
|
2011-10-22 05:33:30 -06:00
|
|
|
const __u16 smb_file_id, const __u32 netpid, const int get_flag,
|
|
|
|
const __u64 len, struct file_lock *pLockData,
|
|
|
|
const __u16 lock_type, const bool waitFlag)
|
2006-02-28 15:39:25 -07:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
|
|
|
struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
|
|
|
|
struct cifs_posix_lock *parm_data;
|
|
|
|
int rc = 0;
|
2006-07-14 16:37:11 -06:00
|
|
|
int timeout = 0;
|
2006-02-28 15:39:25 -07:00
|
|
|
int bytes_returned = 0;
|
2007-11-13 15:41:37 -07:00
|
|
|
int resp_buf_type = 0;
|
2006-02-28 15:39:25 -07:00
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
2007-11-13 15:41:37 -07:00
|
|
|
struct kvec iov[1];
|
2006-02-28 15:39:25 -07:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Posix Lock");
|
2006-05-30 12:03:32 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (pLockData == NULL)
|
2008-05-12 22:01:01 -06:00
|
|
|
return -EINVAL;
|
2006-05-30 12:03:32 -06:00
|
|
|
|
2006-02-28 15:39:25 -07:00
|
|
|
rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
params = 6;
|
2006-02-28 15:39:25 -07:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
count = sizeof(struct cifs_posix_lock);
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-02-07 16:25:02 -07:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
|
2006-02-28 15:39:25 -07:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (get_flag)
|
2006-02-28 15:39:25 -07:00
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
|
|
|
|
else
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
2007-07-12 18:33:32 -06:00
|
|
|
parm_data = (struct cifs_posix_lock *)
|
2006-02-28 15:39:25 -07:00
|
|
|
(((char *) &pSMB->hdr.Protocol) + offset);
|
|
|
|
|
|
|
|
parm_data->lock_type = cpu_to_le16(lock_type);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (waitFlag) {
|
2007-11-13 15:41:37 -07:00
|
|
|
timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
|
2006-05-30 12:07:17 -06:00
|
|
|
parm_data->lock_flags = cpu_to_le16(1);
|
2006-07-14 16:37:11 -06:00
|
|
|
pSMB->Timeout = cpu_to_le32(-1);
|
|
|
|
} else
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
|
2011-10-22 05:33:30 -06:00
|
|
|
parm_data->pid = cpu_to_le32(netpid);
|
2006-05-30 12:03:32 -06:00
|
|
|
parm_data->start = cpu_to_le64(pLockData->fl_start);
|
2006-05-30 12:07:17 -06:00
|
|
|
parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
|
2006-02-28 15:39:25 -07:00
|
|
|
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
2006-03-01 02:17:37 -07:00
|
|
|
pSMB->Fid = smb_file_id;
|
2006-02-28 15:39:25 -07:00
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2006-02-28 15:39:25 -07:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
2006-08-02 15:56:33 -06:00
|
|
|
if (waitFlag) {
|
|
|
|
rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned);
|
|
|
|
} else {
|
2007-11-13 15:41:37 -07:00
|
|
|
iov[0].iov_base = (char *)pSMB;
|
2011-04-28 23:40:20 -06:00
|
|
|
iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
|
2007-11-13 15:41:37 -07:00
|
|
|
rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
|
|
|
|
&resp_buf_type, timeout);
|
|
|
|
pSMB = NULL; /* request buf already freed by SendReceive2. Do
|
|
|
|
not try to free it twice below on exit */
|
|
|
|
pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
|
2006-08-02 15:56:33 -06:00
|
|
|
}
|
|
|
|
|
2006-02-28 15:39:25 -07:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Posix Lock = %d", rc);
|
2006-05-30 12:03:32 -06:00
|
|
|
} else if (get_flag) {
|
|
|
|
/* lock structure can be returned on get */
|
|
|
|
__u16 data_offset;
|
|
|
|
__u16 data_count;
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
|
2006-05-30 12:03:32 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
goto plk_err_exit;
|
|
|
|
}
|
|
|
|
data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
data_count = le16_to_cpu(pSMBr->t2.DataCount);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (data_count < sizeof(struct cifs_posix_lock)) {
|
2006-05-30 12:03:32 -06:00
|
|
|
rc = -EIO;
|
|
|
|
goto plk_err_exit;
|
|
|
|
}
|
|
|
|
parm_data = (struct cifs_posix_lock *)
|
|
|
|
((char *)&pSMBr->hdr.Protocol + data_offset);
|
2010-04-04 23:59:14 -06:00
|
|
|
if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
|
2006-05-30 12:03:32 -06:00
|
|
|
pLockData->fl_type = F_UNLCK;
|
2010-04-04 23:59:14 -06:00
|
|
|
else {
|
|
|
|
if (parm_data->lock_type ==
|
|
|
|
__constant_cpu_to_le16(CIFS_RDLCK))
|
|
|
|
pLockData->fl_type = F_RDLCK;
|
|
|
|
else if (parm_data->lock_type ==
|
|
|
|
__constant_cpu_to_le16(CIFS_WRLCK))
|
|
|
|
pLockData->fl_type = F_WRLCK;
|
|
|
|
|
2011-03-12 22:08:25 -07:00
|
|
|
pLockData->fl_start = le64_to_cpu(parm_data->start);
|
|
|
|
pLockData->fl_end = pLockData->fl_start +
|
|
|
|
le64_to_cpu(parm_data->length) - 1;
|
|
|
|
pLockData->fl_pid = le32_to_cpu(parm_data->pid);
|
2010-04-04 23:59:14 -06:00
|
|
|
}
|
2006-02-28 15:39:25 -07:00
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2006-05-30 12:03:32 -06:00
|
|
|
plk_err_exit:
|
2006-02-28 15:39:25 -07:00
|
|
|
if (pSMB)
|
|
|
|
cifs_small_buf_release(pSMB);
|
|
|
|
|
2007-11-13 15:41:37 -07:00
|
|
|
if (resp_buf_type == CIFS_SMALL_BUFFER)
|
|
|
|
cifs_small_buf_release(iov[0].iov_base);
|
|
|
|
else if (resp_buf_type == CIFS_LARGE_BUFFER)
|
|
|
|
cifs_buf_release(iov[0].iov_base);
|
|
|
|
|
2006-02-28 15:39:25 -07:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
CLOSE_REQ *pSMB = NULL;
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBClose");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* do not retry on dead session on close */
|
|
|
|
rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == -EAGAIN)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->FileID = (__u16) smb_file_id;
|
2006-10-01 23:53:29 -06:00
|
|
|
pSMB->LastWriteTime = 0xFFFFFFFF;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = 0;
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_closes);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc != -EINTR) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* EINTR is expected when user ctl-c to kill app */
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in Close = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Since session is dead, file will be closed on server already */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == -EAGAIN)
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-02-21 14:17:43 -07:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
|
2009-02-21 14:17:43 -07:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
FLUSH_REQ *pSMB = NULL;
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBFlush");
|
2009-02-21 14:17:43 -07:00
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->FileID = (__u16) smb_file_id;
|
|
|
|
pSMB->ByteCount = 0;
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2009-02-21 14:17:43 -07:00
|
|
|
cifs_stats_inc(&tcon->num_flushes);
|
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in Flush = %d", rc);
|
2009-02-21 14:17:43 -07:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *fromName, const char *toName,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
RENAME_REQ *pSMB = NULL;
|
|
|
|
RENAME_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len, name_len2;
|
|
|
|
__u16 count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBRename");
|
2005-04-16 16:20:36 -06:00
|
|
|
renameRetry:
|
|
|
|
rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->BufferFormat = 0x04;
|
|
|
|
pSMB->SearchAttributes =
|
|
|
|
cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
|
|
|
|
ATTR_DIRECTORY);
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
pSMB->OldFileName[name_len] = 0x04; /* pad */
|
|
|
|
/* protocol requires ASCII signature byte on Unicode string */
|
|
|
|
pSMB->OldFileName[name_len + 1] = 0x00;
|
|
|
|
name_len2 =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
|
|
|
|
toName, PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
|
|
|
|
name_len2 *= 2; /* convert to bytes */
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fromName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->OldFileName, fromName, name_len);
|
|
|
|
name_len2 = strnlen(toName, PATH_MAX);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
|
|
|
|
strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
name_len2++; /* signature byte */
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 1 /* 1st signature byte */ + name_len + name_len2;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_renames);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in rename = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto renameRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2011-05-26 22:34:02 -06:00
|
|
|
int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
|
2008-09-24 09:32:59 -06:00
|
|
|
int netfid, const char *target_name,
|
2007-07-12 18:33:32 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
|
|
|
struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct set_file_rename *rename_info;
|
2005-04-16 16:20:36 -06:00
|
|
|
char *data_offset;
|
|
|
|
char dummy_string[30];
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
int len_of_str;
|
|
|
|
__u16 params, param_offset, offset, count, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Rename to File by handle");
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 6;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
|
|
|
|
rename_info = (struct set_file_rename *) data_offset;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-02-07 16:25:02 -07:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
/* construct random name ".cifs_tmp<inodenum><mid>" */
|
|
|
|
rename_info->overwrite = cpu_to_le32(1);
|
|
|
|
rename_info->root_fid = 0;
|
|
|
|
/* unicode only call */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (target_name == NULL) {
|
2007-07-12 18:33:32 -06:00
|
|
|
sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
|
2012-01-18 21:32:33 -07:00
|
|
|
len_of_str =
|
|
|
|
cifsConvertToUTF16((__le16 *)rename_info->target_name,
|
2005-04-28 23:41:06 -06:00
|
|
|
dummy_string, 24, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-01-18 21:32:33 -07:00
|
|
|
len_of_str =
|
|
|
|
cifsConvertToUTF16((__le16 *)rename_info->target_name,
|
2007-07-12 18:33:32 -06:00
|
|
|
target_name, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
|
2008-09-24 09:32:59 -06:00
|
|
|
count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
|
2005-04-16 16:20:36 -06:00
|
|
|
byte_count += count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->Fid = netfid;
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&pTcon->num_t2renames);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Rename (by file handle) = %d", rc);
|
2005-08-20 22:42:53 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
|
2007-07-12 18:33:32 -06:00
|
|
|
const __u16 target_tid, const char *toName, const int flags,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
COPY_REQ *pSMB = NULL;
|
|
|
|
COPY_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len, name_len2;
|
|
|
|
__u16 count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBCopy");
|
2005-04-16 16:20:36 -06:00
|
|
|
copyRetry:
|
|
|
|
rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->BufferFormat = 0x04;
|
|
|
|
pSMB->Tid2 = target_tid;
|
|
|
|
|
|
|
|
pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
2012-01-18 21:32:33 -07:00
|
|
|
name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
|
|
|
|
fromName, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
pSMB->OldFileName[name_len] = 0x04; /* pad */
|
|
|
|
/* protocol requires ASCII signature byte on Unicode string */
|
|
|
|
pSMB->OldFileName[name_len + 1] = 0x00;
|
2007-07-12 18:33:32 -06:00
|
|
|
name_len2 =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
|
|
|
|
toName, PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
|
|
|
|
name_len2 *= 2; /* convert to bytes */
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fromName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->OldFileName, fromName, name_len);
|
|
|
|
name_len2 = strnlen(toName, PATH_MAX);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
|
|
|
|
strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
name_len2++; /* signature byte */
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 1 /* 1st signature byte */ + name_len + name_len2;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in copy = %d with %d files copied",
|
|
|
|
rc, le16_to_cpu(pSMBr->CopyCount));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-05-21 20:02:03 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto copyRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *fromName, const char *toName,
|
|
|
|
const struct nls_table *nls_codepage)
|
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
char *data_offset;
|
|
|
|
int name_len;
|
|
|
|
int name_len_target;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In Symlink Unix style");
|
2005-04-16 16:20:36 -06:00
|
|
|
createSymLinkRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
|
|
|
|
/* find define for this maxpathcomponent */
|
|
|
|
PATH_MAX, nls_codepage);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fromName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fromName, name_len);
|
|
|
|
}
|
|
|
|
params = 6 + name_len;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len_target =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
|
|
|
|
/* find define for this maxpathcomponent */
|
|
|
|
, nls_codepage);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len_target++; /* trailing null */
|
|
|
|
name_len_target *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len_target = strnlen(toName, PATH_MAX);
|
|
|
|
name_len_target++; /* trailing null */
|
|
|
|
strncpy(data_offset, toName, name_len_target);
|
|
|
|
}
|
|
|
|
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find exact max on data count below from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + name_len_target;
|
|
|
|
pSMB->DataCount = cpu_to_le16(name_len_target);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_symlinks);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-21 20:02:03 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto createSymLinkRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *fromName, const char *toName,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
char *data_offset;
|
|
|
|
int name_len;
|
|
|
|
int name_len_target;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In Create Hard link Unix style");
|
2005-04-16 16:20:36 -06:00
|
|
|
createHardLinkRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
2012-01-18 21:32:33 -07:00
|
|
|
name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(toName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, toName, name_len);
|
|
|
|
}
|
|
|
|
params = 6 + name_len;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len_target =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) data_offset, fromName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len_target++; /* trailing null */
|
|
|
|
name_len_target *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len_target = strnlen(fromName, PATH_MAX);
|
|
|
|
name_len_target++; /* trailing null */
|
|
|
|
strncpy(data_offset, fromName, name_len_target);
|
|
|
|
}
|
|
|
|
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find exact max on data count below from sess*/
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + name_len_target;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->DataCount = cpu_to_le16(name_len_target);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_hardlinks);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto createHardLinkRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const char *fromName, const char *toName,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
NT_RENAME_REQ *pSMB = NULL;
|
|
|
|
RENAME_RSP *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len, name_len2;
|
|
|
|
__u16 count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSCreateHardLink");
|
2005-04-16 16:20:36 -06:00
|
|
|
winCreateHardLinkRetry:
|
|
|
|
|
|
|
|
rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->SearchAttributes =
|
|
|
|
cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
|
|
|
|
ATTR_DIRECTORY);
|
|
|
|
pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
|
|
|
|
pSMB->ClusterCount = 0;
|
|
|
|
|
|
|
|
pSMB->BufferFormat = 0x04;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2009-02-28 10:59:03 -07:00
|
|
|
|
|
|
|
/* protocol specifies ASCII buffer format (0x04) for unicode */
|
|
|
|
pSMB->OldFileName[name_len] = 0x04;
|
|
|
|
pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len2 =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
|
|
|
|
toName, PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
|
|
|
|
name_len2 *= 2; /* convert to bytes */
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fromName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->OldFileName, fromName, name_len);
|
|
|
|
name_len2 = strnlen(toName, PATH_MAX);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
|
|
|
|
strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
|
|
|
|
name_len2++; /* trailing null */
|
|
|
|
name_len2++; /* signature byte */
|
|
|
|
}
|
|
|
|
|
|
|
|
count = 1 /* string type byte */ + name_len + name_len2;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_hardlinks);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in hard link (NT rename) = %d", rc);
|
2008-02-07 16:25:02 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto winCreateHardLinkRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
|
2009-04-30 05:17:56 -06:00
|
|
|
const unsigned char *searchName, char **symlinkinfo,
|
2005-04-16 16:20:36 -06:00
|
|
|
const struct nls_table *nls_codepage)
|
|
|
|
{
|
|
|
|
/* SMB_QUERY_FILE_UNIX_LINK */
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
2009-04-30 05:17:56 -06:00
|
|
|
char *data_start;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
querySymLinkRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
|
|
|
|
PATH_MAX, nls_codepage);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2009-05-24 16:45:17 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* decode response */
|
|
|
|
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
/* BB also check enough total bytes returned */
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 2)
|
2009-04-30 05:17:56 -06:00
|
|
|
rc = -EIO;
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2009-04-30 23:27:32 -06:00
|
|
|
bool is_unicode;
|
2009-04-30 05:17:56 -06:00
|
|
|
u16 count = le16_to_cpu(pSMBr->t2.DataCount);
|
|
|
|
|
|
|
|
data_start = ((char *) &pSMBr->hdr.Protocol) +
|
|
|
|
le16_to_cpu(pSMBr->t2.DataOffset);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-30 23:27:32 -06:00
|
|
|
if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
|
|
|
|
is_unicode = true;
|
|
|
|
else
|
|
|
|
is_unicode = false;
|
|
|
|
|
2005-04-28 23:41:06 -06:00
|
|
|
/* BB FIXME investigate remapping reserved chars here */
|
2012-01-18 21:32:33 -07:00
|
|
|
*symlinkinfo = cifs_strndup_from_utf16(data_start,
|
|
|
|
count, is_unicode, nls_codepage);
|
2009-05-19 07:57:03 -06:00
|
|
|
if (!*symlinkinfo)
|
2009-04-30 05:17:56 -06:00
|
|
|
rc = -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto querySymLinkRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2011-02-23 23:16:22 -07:00
|
|
|
#ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
|
|
|
|
/*
|
|
|
|
* Recent Windows versions now create symlinks more frequently
|
|
|
|
* and they use the "reparse point" mechanism below. We can of course
|
|
|
|
* do symlinks nicely to Samba and other servers which support the
|
|
|
|
* CIFS Unix Extensions and we can also do SFU symlinks and "client only"
|
|
|
|
* "MF" symlinks optionally, but for recent Windows we really need to
|
|
|
|
* reenable the code below and fix the cifs_symlink callers to handle this.
|
|
|
|
* In the interim this code has been moved to its own config option so
|
|
|
|
* it is not compiled in by default until callers fixed up and more tested.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const unsigned char *searchName,
|
2007-07-12 18:33:32 -06:00
|
|
|
char *symlinkinfo, const int buflen, __u16 fid,
|
2005-04-16 16:20:36 -06:00
|
|
|
const struct nls_table *nls_codepage)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction_ioctl_req *pSMB;
|
|
|
|
struct smb_com_transaction_ioctl_rsp *pSMBr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->TotalParameterCount = 0 ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le32(2);
|
|
|
|
/* BB find exact data count max from sess structure BB */
|
2011-10-11 04:41:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 4;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->ParameterOffset = 0;
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 4;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
|
|
|
|
pSMB->IsFsctl = 1; /* FSCTL */
|
|
|
|
pSMB->IsRootFlag = 0;
|
|
|
|
pSMB->Fid = fid; /* file handle always le */
|
|
|
|
pSMB->ByteCount = 0;
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
__u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
|
|
|
|
__u32 data_count = le32_to_cpu(pSMBr->DataCount);
|
2011-05-04 06:05:26 -06:00
|
|
|
if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
|
|
|
|
/* BB also check enough total bytes returned */
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
2009-05-01 23:25:46 -06:00
|
|
|
goto qreparse_out;
|
|
|
|
}
|
|
|
|
if (data_count && (data_count < 2048)) {
|
|
|
|
char *end_of_smb = 2 /* sizeof byte count */ +
|
2011-05-04 06:05:26 -06:00
|
|
|
get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-05-01 23:25:46 -06:00
|
|
|
struct reparse_data *reparse_buf =
|
2007-07-12 18:33:32 -06:00
|
|
|
(struct reparse_data *)
|
|
|
|
((char *)&pSMBr->hdr.Protocol
|
|
|
|
+ data_offset);
|
2009-05-01 23:25:46 -06:00
|
|
|
if ((char *)reparse_buf >= end_of_smb) {
|
|
|
|
rc = -EIO;
|
|
|
|
goto qreparse_out;
|
|
|
|
}
|
|
|
|
if ((reparse_buf->LinkNamesBuf +
|
|
|
|
reparse_buf->TargetNameOffset +
|
|
|
|
reparse_buf->TargetNameLen) > end_of_smb) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "reparse buf beyond SMB");
|
2009-05-01 23:25:46 -06:00
|
|
|
rc = -EIO;
|
|
|
|
goto qreparse_out;
|
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2009-05-01 23:25:46 -06:00
|
|
|
if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
cifs_from_ucs2(symlinkinfo, (__le16 *)
|
2007-07-12 18:33:32 -06:00
|
|
|
(reparse_buf->LinkNamesBuf +
|
|
|
|
reparse_buf->TargetNameOffset),
|
2009-05-01 23:25:46 -06:00
|
|
|
buflen,
|
|
|
|
reparse_buf->TargetNameLen,
|
|
|
|
nls_codepage, 0);
|
|
|
|
} else { /* ASCII names */
|
|
|
|
strncpy(symlinkinfo,
|
|
|
|
reparse_buf->LinkNamesBuf +
|
|
|
|
reparse_buf->TargetNameOffset,
|
|
|
|
min_t(const int, buflen,
|
|
|
|
reparse_buf->TargetNameLen));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-05-01 23:25:46 -06:00
|
|
|
} else {
|
|
|
|
rc = -EIO;
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Invalid return data count on "
|
|
|
|
"get reparse info ioctl");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-05-01 23:25:46 -06:00
|
|
|
symlinkinfo[buflen] = 0; /* just in case so the caller
|
|
|
|
does not go off the end of the buffer */
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "readlink result - %s", symlinkinfo);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-05-01 23:32:20 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
qreparse_out:
|
2005-08-13 09:15:54 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2011-02-23 23:16:22 -07:00
|
|
|
#endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_CIFS_POSIX
|
|
|
|
|
|
|
|
/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
|
2007-07-12 18:33:32 -06:00
|
|
|
static void cifs_convert_ace(posix_acl_xattr_entry *ace,
|
|
|
|
struct cifs_posix_ace *cifs_ace)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* u8 cifs fields do not need le conversion */
|
2005-11-15 17:45:16 -07:00
|
|
|
ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
|
|
|
|
ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
|
|
|
|
ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
|
2010-04-20 21:50:45 -06:00
|
|
|
/* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
|
2007-07-12 18:33:32 -06:00
|
|
|
static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
|
|
|
|
const int acl_type, const int size_of_data_area)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int size = 0;
|
|
|
|
int i;
|
|
|
|
__u16 count;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct cifs_posix_ace *pACE;
|
|
|
|
struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
|
|
|
|
posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (acl_type & ACL_TYPE_ACCESS) {
|
2005-04-16 16:20:36 -06:00
|
|
|
count = le16_to_cpu(cifs_acl->access_entry_count);
|
|
|
|
pACE = &cifs_acl->ace_array[0];
|
|
|
|
size = sizeof(struct cifs_posix_acl);
|
|
|
|
size += sizeof(struct cifs_posix_ace) * count;
|
|
|
|
/* check if we would go beyond end of SMB */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (size_of_data_area < size) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
|
|
|
|
size_of_data_area, size);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (acl_type & ACL_TYPE_DEFAULT) {
|
2005-04-16 16:20:36 -06:00
|
|
|
count = le16_to_cpu(cifs_acl->access_entry_count);
|
|
|
|
size = sizeof(struct cifs_posix_acl);
|
|
|
|
size += sizeof(struct cifs_posix_ace) * count;
|
|
|
|
/* skip past access ACEs to get to default ACEs */
|
|
|
|
pACE = &cifs_acl->ace_array[count];
|
|
|
|
count = le16_to_cpu(cifs_acl->default_entry_count);
|
|
|
|
size += sizeof(struct cifs_posix_ace) * count;
|
|
|
|
/* check if we would go beyond end of SMB */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (size_of_data_area < size)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
/* illegal type */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = posix_acl_xattr_size(count);
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((buflen == 0) || (local_acl == NULL)) {
|
2007-07-12 18:33:32 -06:00
|
|
|
/* used to query ACL EA size */
|
2007-07-07 13:25:05 -06:00
|
|
|
} else if (size > buflen) {
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ERANGE;
|
|
|
|
} else /* buffer big enough */ {
|
2005-11-15 17:45:16 -07:00
|
|
|
local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
|
2007-07-12 18:33:32 -06:00
|
|
|
for (i = 0; i < count ; i++) {
|
|
|
|
cifs_convert_ace(&local_acl->a_entries[i], pACE);
|
|
|
|
pACE++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
|
|
|
|
const posix_acl_xattr_entry *local_ace)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
__u16 rc = 0; /* 0 = ACL converted ok */
|
|
|
|
|
2005-11-15 17:45:16 -07:00
|
|
|
cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
|
|
|
|
cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* BB is there a better way to handle the large uid? */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (local_ace->e_id == cpu_to_le32(-1)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Probably no need to le convert -1 on any arch but can not hurt */
|
|
|
|
cifs_ace->cifs_uid = cpu_to_le64(-1);
|
2007-07-12 18:33:32 -06:00
|
|
|
} else
|
2005-11-15 17:45:16 -07:00
|
|
|
cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
|
2010-04-20 21:50:45 -06:00
|
|
|
/*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
|
2005-04-16 16:20:36 -06:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
|
2007-07-12 18:33:32 -06:00
|
|
|
static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
|
|
|
|
const int buflen, const int acl_type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
__u16 rc = 0;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
|
|
|
|
posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
|
2005-04-16 16:20:36 -06:00
|
|
|
int count;
|
|
|
|
int i;
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
count = posix_acl_xattr_count((size_t)buflen);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "setting acl with %d entries from buf of length %d and "
|
2007-07-17 11:34:02 -06:00
|
|
|
"version of %d",
|
2010-04-20 21:50:45 -06:00
|
|
|
count, buflen, le32_to_cpu(local_acl->a_version));
|
2007-07-07 13:25:05 -06:00
|
|
|
if (le32_to_cpu(local_acl->a_version) != 2) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "unknown POSIX ACL version %d",
|
|
|
|
le32_to_cpu(local_acl->a_version));
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
cifs_acl->version = cpu_to_le16(1);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (acl_type == ACL_TYPE_ACCESS)
|
2005-11-15 17:45:16 -07:00
|
|
|
cifs_acl->access_entry_count = cpu_to_le16(count);
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (acl_type == ACL_TYPE_DEFAULT)
|
2005-11-15 17:45:16 -07:00
|
|
|
cifs_acl->default_entry_count = cpu_to_le16(count);
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "unknown ACL type %d", acl_type);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2007-07-12 18:33:32 -06:00
|
|
|
for (i = 0; i < count; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
|
|
|
|
&local_acl->a_entries[i]);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* ACE not converted */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = (__u16)(count * sizeof(struct cifs_posix_ace));
|
|
|
|
rc += sizeof(struct cifs_posix_acl);
|
|
|
|
/* BB add check to make sure ACL does not overflow SMB */
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const unsigned char *searchName,
|
|
|
|
char *acl_inf, const int buflen, const int acl_type,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* SMB_QUERY_POSIX_ACL */
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
queryAclRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName,
|
|
|
|
searchName, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
|
|
|
pSMB->FileName[name_len] = 0;
|
|
|
|
pSMB->FileName[name_len+1] = 0;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2007-07-12 18:33:32 -06:00
|
|
|
/* BB find exact max data count below from sess structure BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4000);
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(
|
2007-07-12 18:33:32 -06:00
|
|
|
offsetof(struct smb_com_transaction2_qpi_req,
|
|
|
|
InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2006-01-12 16:44:21 -07:00
|
|
|
cifs_stats_inc(&tcon->num_acl_get);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Query POSIX ACL = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* decode response */
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
/* BB also check enough total bytes returned */
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 2)
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
|
|
|
|
rc = cifs_copy_posix_acl(acl_inf,
|
|
|
|
(char *)&pSMBr->hdr.Protocol+data_offset,
|
2007-07-12 18:33:32 -06:00
|
|
|
buflen, acl_type, count);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto queryAclRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const unsigned char *fileName,
|
|
|
|
const char *local_acl, const int buflen,
|
|
|
|
const int acl_type,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_spi_req *pSMB = NULL;
|
|
|
|
struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
|
|
|
|
char *parm_data;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count, data_count, param_offset, offset;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
|
2005-04-16 16:20:36 -06:00
|
|
|
setAclRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(void **) &pSMBr);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
params = 6 + name_len;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find max SMB size from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
|
|
|
|
/* convert to on the wire format for POSIX ACL */
|
2007-07-12 18:33:32 -06:00
|
|
|
data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (data_count == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EOPNOTSUPP;
|
|
|
|
goto setACLerrorExit;
|
|
|
|
}
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
|
|
|
|
byte_count = 3 /* pad */ + params + data_count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(data_count);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Set POSIX ACL returned %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
setACLerrorExit:
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto setAclRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-28 23:41:04 -06:00
|
|
|
/* BB fix tabs in this function FIXME BB */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
|
2008-02-07 16:25:02 -07:00
|
|
|
const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
|
2005-04-28 23:41:04 -06:00
|
|
|
{
|
2007-07-12 18:33:32 -06:00
|
|
|
int rc = 0;
|
|
|
|
struct smb_t2_qfi_req *pSMB = NULL;
|
|
|
|
struct smb_t2_qfi_rsp *pSMBr = NULL;
|
|
|
|
int bytes_returned;
|
|
|
|
__u16 params, byte_count;
|
2005-04-28 23:41:04 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In GetExtAttr");
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon == NULL)
|
|
|
|
return -ENODEV;
|
2005-04-28 23:41:04 -06:00
|
|
|
|
|
|
|
GetExtAttrRetry:
|
2007-07-07 13:25:05 -06:00
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2005-04-28 23:41:04 -06:00
|
|
|
|
2008-02-07 16:25:02 -07:00
|
|
|
params = 2 /* level */ + 2 /* fid */;
|
2007-07-07 13:25:05 -06:00
|
|
|
pSMB->t2.TotalDataCount = 0;
|
|
|
|
pSMB->t2.MaxParameterCount = cpu_to_le16(4);
|
|
|
|
/* BB find exact max data count below from sess structure BB */
|
|
|
|
pSMB->t2.MaxDataCount = cpu_to_le16(4000);
|
|
|
|
pSMB->t2.MaxSetupCount = 0;
|
|
|
|
pSMB->t2.Reserved = 0;
|
|
|
|
pSMB->t2.Flags = 0;
|
|
|
|
pSMB->t2.Timeout = 0;
|
|
|
|
pSMB->t2.Reserved2 = 0;
|
|
|
|
pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
|
|
|
|
Fid) - 4);
|
|
|
|
pSMB->t2.DataCount = 0;
|
|
|
|
pSMB->t2.DataOffset = 0;
|
|
|
|
pSMB->t2.SetupCount = 1;
|
|
|
|
pSMB->t2.Reserved3 = 0;
|
|
|
|
pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->t2.TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
|
|
|
|
pSMB->Pad = 0;
|
2005-04-28 23:41:04 -06:00
|
|
|
pSMB->Fid = netfid;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2007-07-07 13:25:05 -06:00
|
|
|
pSMB->t2.ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "error %d in GetExtAttr", rc);
|
2007-07-07 13:25:05 -06:00
|
|
|
} else {
|
|
|
|
/* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
/* BB also check enough total bytes returned */
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 2)
|
2007-07-07 13:25:05 -06:00
|
|
|
/* If rc should we check for EOPNOSUPP and
|
|
|
|
disable the srvino flag? or in caller? */
|
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
|
|
|
|
struct file_chattr_info *pfinfo;
|
|
|
|
/* BB Do we need a cast or hash here ? */
|
|
|
|
if (count != 16) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Illegal size ret in GetExtAttr");
|
2007-07-07 13:25:05 -06:00
|
|
|
rc = -EIO;
|
|
|
|
goto GetExtAttrOut;
|
|
|
|
}
|
|
|
|
pfinfo = (struct file_chattr_info *)
|
|
|
|
(data_offset + (char *) &pSMBr->hdr.Protocol);
|
|
|
|
*pExtAttrBits = le64_to_cpu(pfinfo->mode);
|
2005-04-28 23:41:04 -06:00
|
|
|
*pMask = le64_to_cpu(pfinfo->mask);
|
2007-07-07 13:25:05 -06:00
|
|
|
}
|
|
|
|
}
|
2005-04-28 23:41:04 -06:00
|
|
|
GetExtAttrOut:
|
2007-07-07 13:25:05 -06:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto GetExtAttrRetry;
|
|
|
|
return rc;
|
2005-04-28 23:41:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_POSIX */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-06 10:52:08 -07:00
|
|
|
#ifdef CONFIG_CIFS_ACL
|
|
|
|
/*
|
|
|
|
* Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
|
|
|
|
* all NT TRANSACTS that we init here have total parm and data under about 400
|
|
|
|
* bytes (to fit in small cifs buffer size), which is the case so far, it
|
|
|
|
* easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
|
|
|
|
* returned setup area) and MaxParameterCount (returned parms size) must be set
|
|
|
|
* by caller
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
smb_init_nttransact(const __u16 sub_command, const int setup_count,
|
2011-05-26 22:34:02 -06:00
|
|
|
const int parm_len, struct cifs_tcon *tcon,
|
2010-12-06 10:52:08 -07:00
|
|
|
void **ret_buf)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
__u32 temp_offset;
|
|
|
|
struct smb_com_ntransact_req *pSMB;
|
|
|
|
|
|
|
|
rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
|
|
|
|
(void **)&pSMB);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
*ret_buf = (void *)pSMB;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le32(parm_len);
|
|
|
|
pSMB->TotalDataCount = 0;
|
2011-10-11 04:41:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
|
2010-12-06 10:52:08 -07:00
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->DataCount = pSMB->TotalDataCount;
|
|
|
|
temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
|
|
|
|
(setup_count * 2) - 4 /* for rfc1001 length itself */;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le32(temp_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
|
|
|
|
pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
|
|
|
|
pSMB->SubCommand = cpu_to_le16(sub_command);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
validate_ntransact(char *buf, char **ppparm, char **ppdata,
|
|
|
|
__u32 *pparmlen, __u32 *pdatalen)
|
|
|
|
{
|
|
|
|
char *end_of_smb;
|
|
|
|
__u32 data_count, data_offset, parm_count, parm_offset;
|
|
|
|
struct smb_com_ntransact_rsp *pSMBr;
|
2011-05-04 06:05:26 -06:00
|
|
|
u16 bcc;
|
2010-12-06 10:52:08 -07:00
|
|
|
|
|
|
|
*pdatalen = 0;
|
|
|
|
*pparmlen = 0;
|
|
|
|
|
|
|
|
if (buf == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pSMBr = (struct smb_com_ntransact_rsp *)buf;
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
bcc = get_bcc(&pSMBr->hdr);
|
|
|
|
end_of_smb = 2 /* sizeof byte count */ + bcc +
|
2010-12-06 10:52:08 -07:00
|
|
|
(char *)&pSMBr->ByteCount;
|
|
|
|
|
|
|
|
data_offset = le32_to_cpu(pSMBr->DataOffset);
|
|
|
|
data_count = le32_to_cpu(pSMBr->DataCount);
|
|
|
|
parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
|
|
|
|
parm_count = le32_to_cpu(pSMBr->ParameterCount);
|
|
|
|
|
|
|
|
*ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
|
|
|
|
*ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
|
|
|
|
|
|
|
|
/* should we also check that parm and data areas do not overlap? */
|
|
|
|
if (*ppparm > end_of_smb) {
|
|
|
|
cFYI(1, "parms start after end of smb");
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (parm_count + *ppparm > end_of_smb) {
|
|
|
|
cFYI(1, "parm end after end of smb");
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (*ppdata > end_of_smb) {
|
|
|
|
cFYI(1, "data starts after end of smb");
|
|
|
|
return -EINVAL;
|
|
|
|
} else if (data_count + *ppdata > end_of_smb) {
|
|
|
|
cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
|
|
|
|
*ppdata, data_count, (data_count + *ppdata),
|
|
|
|
end_of_smb, pSMBr);
|
|
|
|
return -EINVAL;
|
2011-05-04 06:05:26 -06:00
|
|
|
} else if (parm_count + data_count > bcc) {
|
2010-12-06 10:52:08 -07:00
|
|
|
cFYI(1, "parm count and data count larger than SMB");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
*pdatalen = data_count;
|
|
|
|
*pparmlen = parm_count;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-12 16:44:21 -07:00
|
|
|
/* Get Security Descriptor (by handle) from remote server for a file or dir */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
|
2007-10-25 15:17:17 -06:00
|
|
|
struct cifs_ntsd **acl_inf, __u32 *pbuflen)
|
2006-01-12 16:44:21 -07:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
int buf_type = 0;
|
2008-02-07 16:25:02 -07:00
|
|
|
QUERY_SEC_DESC_REQ *pSMB;
|
2006-01-12 16:44:21 -07:00
|
|
|
struct kvec iov[1];
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "GetCifsACL");
|
2006-01-12 16:44:21 -07:00
|
|
|
|
2007-10-25 15:17:17 -06:00
|
|
|
*pbuflen = 0;
|
|
|
|
*acl_inf = NULL;
|
|
|
|
|
2007-10-26 17:40:20 -06:00
|
|
|
rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
|
2006-01-12 16:44:21 -07:00
|
|
|
8 /* parm len */, tcon, (void **) &pSMB);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le32(4);
|
|
|
|
/* BB TEST with big acls that might need to be e.g. larger than 16K */
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Fid = fid; /* file handle always le */
|
|
|
|
pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
|
|
|
|
CIFS_ACL_DACL);
|
|
|
|
pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, 11);
|
2006-01-12 16:44:21 -07:00
|
|
|
iov[0].iov_base = (char *)pSMB;
|
2011-04-28 23:40:20 -06:00
|
|
|
iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
|
2006-01-12 16:44:21 -07:00
|
|
|
|
2007-10-18 15:45:27 -06:00
|
|
|
rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
|
2011-01-11 05:24:23 -07:00
|
|
|
0);
|
2006-01-12 16:44:21 -07:00
|
|
|
cifs_stats_inc(&tcon->num_acl_get);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QuerySecDesc = %d", rc);
|
2006-01-12 16:44:21 -07:00
|
|
|
} else { /* decode response */
|
2008-02-07 16:25:02 -07:00
|
|
|
__le32 *parm;
|
2007-10-25 15:17:17 -06:00
|
|
|
__u32 parm_len;
|
|
|
|
__u32 acl_len;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_ntransact_rsp *pSMBr;
|
2007-10-25 15:17:17 -06:00
|
|
|
char *pdata;
|
2006-01-12 16:44:21 -07:00
|
|
|
|
|
|
|
/* validate_nttransact */
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
|
2007-10-25 15:17:17 -06:00
|
|
|
&pdata, &parm_len, pbuflen);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc)
|
2006-01-12 16:44:21 -07:00
|
|
|
goto qsec_out;
|
|
|
|
pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
|
2006-01-12 16:44:21 -07:00
|
|
|
|
|
|
|
if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
|
|
|
|
rc = -EIO; /* bad smb */
|
2007-10-25 15:17:17 -06:00
|
|
|
*pbuflen = 0;
|
2006-01-12 16:44:21 -07:00
|
|
|
goto qsec_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* BB check that data area is minimum length and as big as acl_len */
|
|
|
|
|
2007-10-16 12:40:37 -06:00
|
|
|
acl_len = le32_to_cpu(*parm);
|
2007-10-25 15:17:17 -06:00
|
|
|
if (acl_len != *pbuflen) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "acl length %d does not match %d",
|
|
|
|
acl_len, *pbuflen);
|
2007-10-25 15:17:17 -06:00
|
|
|
if (*pbuflen > acl_len)
|
|
|
|
*pbuflen = acl_len;
|
|
|
|
}
|
2006-01-12 16:44:21 -07:00
|
|
|
|
2007-10-25 15:17:17 -06:00
|
|
|
/* check if buffer is big enough for the acl
|
|
|
|
header followed by the smallest SID */
|
|
|
|
if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
|
|
|
|
(*pbuflen >= 64 * 1024)) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "bad acl length %d", *pbuflen);
|
2007-10-25 15:17:17 -06:00
|
|
|
rc = -EINVAL;
|
|
|
|
*pbuflen = 0;
|
|
|
|
} else {
|
|
|
|
*acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
|
|
|
|
if (*acl_inf == NULL) {
|
|
|
|
*pbuflen = 0;
|
|
|
|
rc = -ENOMEM;
|
|
|
|
}
|
|
|
|
memcpy(*acl_inf, pdata, *pbuflen);
|
|
|
|
}
|
2006-01-12 16:44:21 -07:00
|
|
|
}
|
|
|
|
qsec_out:
|
2007-07-07 13:25:05 -06:00
|
|
|
if (buf_type == CIFS_SMALL_BUFFER)
|
2006-01-12 16:44:21 -07:00
|
|
|
cifs_small_buf_release(iov[0].iov_base);
|
2007-07-07 13:25:05 -06:00
|
|
|
else if (buf_type == CIFS_LARGE_BUFFER)
|
2006-01-12 16:44:21 -07:00
|
|
|
cifs_buf_release(iov[0].iov_base);
|
2006-02-26 09:41:18 -07:00
|
|
|
/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
|
2006-01-12 16:44:21 -07:00
|
|
|
return rc;
|
|
|
|
}
|
2007-12-31 00:47:21 -07:00
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
|
2011-10-13 09:26:03 -06:00
|
|
|
struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
|
2007-12-31 00:47:21 -07:00
|
|
|
{
|
|
|
|
__u16 byte_count, param_count, data_count, param_offset, data_offset;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
SET_SEC_DESC_REQ *pSMB = NULL;
|
2012-03-26 07:55:29 -06:00
|
|
|
void *pSMBr;
|
2007-12-31 00:47:21 -07:00
|
|
|
|
|
|
|
setCifsAclRetry:
|
2012-03-26 07:55:29 -06:00
|
|
|
rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
|
2007-12-31 00:47:21 -07:00
|
|
|
if (rc)
|
2012-03-26 07:55:29 -06:00
|
|
|
return rc;
|
2007-12-31 00:47:21 -07:00
|
|
|
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
|
|
|
|
param_count = 8;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
|
|
|
|
data_count = acllen;
|
|
|
|
data_offset = param_offset + param_count;
|
|
|
|
byte_count = 3 /* pad */ + param_count;
|
|
|
|
|
|
|
|
pSMB->DataCount = cpu_to_le32(data_count);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le32(4);
|
|
|
|
pSMB->MaxDataCount = cpu_to_le32(16384);
|
|
|
|
pSMB->ParameterCount = cpu_to_le32(param_count);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le32(param_offset);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->DataOffset = cpu_to_le32(data_offset);
|
|
|
|
pSMB->SetupCount = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
|
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
|
|
|
|
|
|
|
|
pSMB->Fid = fid; /* file handle always le */
|
|
|
|
pSMB->Reserved2 = 0;
|
2011-10-13 09:26:03 -06:00
|
|
|
pSMB->AclFlags = cpu_to_le32(aclflag);
|
2007-12-31 00:47:21 -07:00
|
|
|
|
|
|
|
if (pntsd && acllen) {
|
2012-03-26 07:55:29 -06:00
|
|
|
memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
|
|
|
|
data_offset, pntsd, acllen);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count + data_count);
|
2007-12-31 00:47:21 -07:00
|
|
|
} else
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2007-12-31 00:47:21 -07:00
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
|
2007-12-31 00:47:21 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Set CIFS ACL returned %d", rc);
|
2007-12-31 00:47:21 -07:00
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto setCifsAclRetry;
|
|
|
|
|
|
|
|
return (rc);
|
|
|
|
}
|
|
|
|
|
2010-12-06 10:52:08 -07:00
|
|
|
#endif /* CONFIG_CIFS_ACL */
|
2006-01-12 16:44:21 -07:00
|
|
|
|
2005-08-23 21:26:03 -06:00
|
|
|
/* Legacy Query Path Information call for lookup to old servers such
|
|
|
|
as Win9x/WinME */
|
2011-05-26 22:34:02 -06:00
|
|
|
int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const unsigned char *searchName,
|
|
|
|
FILE_ALL_INFO *pFinfo,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-08-23 21:26:03 -06:00
|
|
|
{
|
2008-02-07 16:25:02 -07:00
|
|
|
QUERY_INFORMATION_REQ *pSMB;
|
|
|
|
QUERY_INFORMATION_RSP *pSMBr;
|
2005-08-23 21:26:03 -06:00
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SMBQPath path %s", searchName);
|
2005-08-23 21:26:03 -06:00
|
|
|
QInfRetry:
|
|
|
|
rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(void **) &pSMBr);
|
2005-08-23 21:26:03 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName,
|
|
|
|
searchName, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-08-23 21:26:03 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else {
|
2005-08-23 21:26:03 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
pSMB->BufferFormat = 0x04;
|
2007-07-12 18:33:32 -06:00
|
|
|
name_len++; /* account for buffer type byte */
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, (__u16)name_len);
|
2005-08-23 21:26:03 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(name_len);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-23 21:26:03 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QueryInfo = %d", rc);
|
2008-02-07 16:25:02 -07:00
|
|
|
} else if (pFinfo) {
|
2006-09-27 21:35:57 -06:00
|
|
|
struct timespec ts;
|
|
|
|
__u32 time = le32_to_cpu(pSMBr->last_write_time);
|
2008-02-07 16:25:02 -07:00
|
|
|
|
|
|
|
/* decode response */
|
2006-09-27 21:35:57 -06:00
|
|
|
/* BB FIXME - add time zone adjustment BB */
|
2005-08-23 21:26:03 -06:00
|
|
|
memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
|
2006-09-27 21:35:57 -06:00
|
|
|
ts.tv_nsec = 0;
|
|
|
|
ts.tv_sec = time;
|
|
|
|
/* decode time fields */
|
2006-10-14 09:48:26 -06:00
|
|
|
pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
|
2006-09-27 21:35:57 -06:00
|
|
|
pFinfo->LastWriteTime = pFinfo->ChangeTime;
|
|
|
|
pFinfo->LastAccessTime = 0;
|
2005-09-22 17:32:06 -06:00
|
|
|
pFinfo->AllocationSize =
|
|
|
|
cpu_to_le64(le32_to_cpu(pSMBr->size));
|
|
|
|
pFinfo->EndOfFile = pFinfo->AllocationSize;
|
|
|
|
pFinfo->Attributes =
|
|
|
|
cpu_to_le32(le16_to_cpu(pSMBr->attr));
|
2005-08-23 21:26:03 -06:00
|
|
|
} else
|
|
|
|
rc = -EIO; /* bad buffer passed in */
|
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QInfRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-02-12 05:44:16 -07:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
|
2010-02-12 05:44:16 -07:00
|
|
|
u16 netfid, FILE_ALL_INFO *pFindData)
|
|
|
|
{
|
|
|
|
struct smb_t2_qfi_req *pSMB = NULL;
|
|
|
|
struct smb_t2_qfi_rsp *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
|
|
|
QFileInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2 /* level */ + 2 /* fid */;
|
|
|
|
pSMB->t2.TotalDataCount = 0;
|
|
|
|
pSMB->t2.MaxParameterCount = cpu_to_le16(4);
|
|
|
|
/* BB find exact max data count below from sess structure BB */
|
|
|
|
pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
|
|
|
|
pSMB->t2.MaxSetupCount = 0;
|
|
|
|
pSMB->t2.Reserved = 0;
|
|
|
|
pSMB->t2.Flags = 0;
|
|
|
|
pSMB->t2.Timeout = 0;
|
|
|
|
pSMB->t2.Reserved2 = 0;
|
|
|
|
pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
|
|
|
|
Fid) - 4);
|
|
|
|
pSMB->t2.DataCount = 0;
|
|
|
|
pSMB->t2.DataOffset = 0;
|
|
|
|
pSMB->t2.SetupCount = 1;
|
|
|
|
pSMB->t2.Reserved3 = 0;
|
|
|
|
pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->t2.TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
|
|
|
|
pSMB->Pad = 0;
|
|
|
|
pSMB->Fid = netfid;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-08-23 21:26:03 -06:00
|
|
|
|
2010-02-12 05:44:16 -07:00
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 22:12:10 -06:00
|
|
|
cFYI(1, "Send error in QPathInfo = %d", rc);
|
2010-02-12 05:44:16 -07:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2005-08-23 21:26:03 -06:00
|
|
|
|
2010-02-12 05:44:16 -07:00
|
|
|
if (rc) /* BB add auto retry on EOPNOTSUPP? */
|
|
|
|
rc = -EIO;
|
2011-05-04 06:05:26 -06:00
|
|
|
else if (get_bcc(&pSMBr->hdr) < 40)
|
2010-02-12 05:44:16 -07:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else if (pFindData) {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
memcpy((char *) pFindData,
|
|
|
|
(char *) &pSMBr->hdr.Protocol +
|
|
|
|
data_offset, sizeof(FILE_ALL_INFO));
|
|
|
|
} else
|
|
|
|
rc = -ENOMEM;
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFileInfoRetry;
|
2005-08-23 21:26:03 -06:00
|
|
|
|
2010-02-12 05:44:16 -07:00
|
|
|
return rc;
|
|
|
|
}
|
2005-08-23 21:26:03 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const unsigned char *searchName,
|
2008-02-07 16:25:02 -07:00
|
|
|
FILE_ALL_INFO *pFindData,
|
2006-10-11 21:28:28 -06:00
|
|
|
int legacy /* old style infolevel */,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 263 SMB_QUERY_FILE_ALL_INFO */
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
/* cFYI(1, "In QPathInfo path %s", searchName); */
|
2005-04-16 16:20:36 -06:00
|
|
|
QPathInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (legacy)
|
2006-10-11 21:28:28 -06:00
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
|
|
|
|
else
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QPathInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2006-10-11 21:28:28 -06:00
|
|
|
if (rc) /* BB add auto retry on EOPNOTSUPP? */
|
|
|
|
rc = -EIO;
|
2011-05-04 06:05:26 -06:00
|
|
|
else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
2011-05-04 06:05:26 -06:00
|
|
|
else if (legacy && get_bcc(&pSMBr->hdr) < 24)
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = -EIO; /* 24 or 26 expected but we do not read
|
|
|
|
last field */
|
|
|
|
else if (pFindData) {
|
2006-10-11 21:28:28 -06:00
|
|
|
int size;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
2008-02-07 16:25:02 -07:00
|
|
|
|
|
|
|
/* On legacy responses we do not read the last field,
|
|
|
|
EAsize, fortunately since it varies by subdialect and
|
|
|
|
also note it differs on Set vs. Get, ie two bytes or 4
|
|
|
|
bytes depending but we don't care here */
|
|
|
|
if (legacy)
|
2006-10-11 21:28:28 -06:00
|
|
|
size = sizeof(FILE_INFO_STANDARD);
|
|
|
|
else
|
|
|
|
size = sizeof(FILE_ALL_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy((char *) pFindData,
|
|
|
|
(char *) &pSMBr->hdr.Protocol +
|
2006-10-11 21:28:28 -06:00
|
|
|
data_offset, size);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else
|
|
|
|
rc = -ENOMEM;
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QPathInfoRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2010-02-12 05:44:17 -07:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
|
2010-02-12 05:44:17 -07:00
|
|
|
u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
|
|
|
|
{
|
|
|
|
struct smb_t2_qfi_req *pSMB = NULL;
|
|
|
|
struct smb_t2_qfi_rsp *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
|
|
|
UnixQFileInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2 /* level */ + 2 /* fid */;
|
|
|
|
pSMB->t2.TotalDataCount = 0;
|
|
|
|
pSMB->t2.MaxParameterCount = cpu_to_le16(4);
|
|
|
|
/* BB find exact max data count below from sess structure BB */
|
|
|
|
pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
|
|
|
|
pSMB->t2.MaxSetupCount = 0;
|
|
|
|
pSMB->t2.Reserved = 0;
|
|
|
|
pSMB->t2.Flags = 0;
|
|
|
|
pSMB->t2.Timeout = 0;
|
|
|
|
pSMB->t2.Reserved2 = 0;
|
|
|
|
pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
|
|
|
|
Fid) - 4);
|
|
|
|
pSMB->t2.DataCount = 0;
|
|
|
|
pSMB->t2.DataOffset = 0;
|
|
|
|
pSMB->t2.SetupCount = 1;
|
|
|
|
pSMB->t2.Reserved3 = 0;
|
|
|
|
pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->t2.TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
|
|
|
|
pSMB->Pad = 0;
|
|
|
|
pSMB->Fid = netfid;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2010-02-12 05:44:17 -07:00
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 22:12:10 -06:00
|
|
|
cFYI(1, "Send error in QPathInfo = %d", rc);
|
2010-02-12 05:44:17 -07:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
|
2012-07-23 11:14:28 -06:00
|
|
|
cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response. "
|
2010-02-12 05:44:17 -07:00
|
|
|
"Unix Extensions can be disabled on mount "
|
2010-04-20 22:12:10 -06:00
|
|
|
"by specifying the nosfu mount option.");
|
2010-02-12 05:44:17 -07:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
} else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
memcpy((char *) pFindData,
|
|
|
|
(char *) &pSMBr->hdr.Protocol +
|
|
|
|
data_offset,
|
|
|
|
sizeof(FILE_UNIX_BASIC_INFO));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto UnixQFileInfoRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
|
2005-04-16 16:20:36 -06:00
|
|
|
const unsigned char *searchName,
|
2008-05-12 22:54:12 -06:00
|
|
|
FILE_UNIX_BASIC_INFO *pFindData,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* SMB_QUERY_FILE_UNIX_BASIC */
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
UnixQPathInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
2007-07-12 18:33:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QPathInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
|
2012-07-23 11:14:28 -06:00
|
|
|
cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response. "
|
2007-09-20 09:30:07 -06:00
|
|
|
"Unix Extensions can be disabled on mount "
|
2010-04-20 21:50:45 -06:00
|
|
|
"by specifying the nosfu mount option.");
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
} else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
memcpy((char *) pFindData,
|
|
|
|
(char *) &pSMBr->hdr.Protocol +
|
|
|
|
data_offset,
|
2007-10-25 15:17:17 -06:00
|
|
|
sizeof(FILE_UNIX_BASIC_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto UnixQPathInfoRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* xid, tcon, searchName and codepage are input parms, rest are returned */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const char *searchName,
|
2005-04-16 16:20:36 -06:00
|
|
|
const struct nls_table *nls_codepage,
|
2012-05-15 09:19:16 -06:00
|
|
|
__u16 *pnetfid, __u16 search_flags,
|
2007-07-12 18:33:32 -06:00
|
|
|
struct cifs_search_info *psrch_inf, int remap, const char dirsep)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 257 SMB_ */
|
|
|
|
TRANSACTION2_FFIRST_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
|
2008-02-07 16:25:02 -07:00
|
|
|
T2_FFIRST_RSP_PARMS *parms;
|
2005-04-16 16:20:36 -06:00
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In FindFirst for %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
findFirstRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-28 23:41:06 -06:00
|
|
|
/* We can not add the asterik earlier in case
|
|
|
|
it got remapped to 0xF03A as if it were part of the
|
|
|
|
directory name instead of a wildcard */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len *= 2;
|
2005-06-22 18:26:35 -06:00
|
|
|
pSMB->FileName[name_len] = dirsep;
|
2005-04-28 23:41:06 -06:00
|
|
|
pSMB->FileName[name_len+1] = 0;
|
|
|
|
pSMB->FileName[name_len+2] = '*';
|
|
|
|
pSMB->FileName[name_len+3] = 0;
|
|
|
|
name_len += 4; /* now the trailing null */
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->FileName[name_len] = 0; /* null terminate just in case */
|
|
|
|
pSMB->FileName[name_len+1] = 0;
|
2005-04-28 23:41:06 -06:00
|
|
|
name_len += 2;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* BB add check for overrun of SMB buf BB */
|
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
/* BB fix here and in unicode clause above ie
|
2007-07-07 13:25:05 -06:00
|
|
|
if (name_len > buffersize-header)
|
2005-04-16 16:20:36 -06:00
|
|
|
free buffer exit; BB */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
2005-06-22 18:26:35 -06:00
|
|
|
pSMB->FileName[name_len] = dirsep;
|
2005-04-30 12:10:57 -06:00
|
|
|
pSMB->FileName[name_len+1] = '*';
|
|
|
|
pSMB->FileName[name_len+2] = 0;
|
|
|
|
name_len += 3;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
params = 12 + name_len /* includes null */ ;
|
|
|
|
pSMB->TotalDataCount = 0; /* no EAs */
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(10);
|
2011-10-11 04:41:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(
|
2006-03-09 15:21:45 -07:00
|
|
|
offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
|
|
|
|
- 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
|
|
|
|
pSMB->SearchAttributes =
|
|
|
|
cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
|
|
|
|
ATTR_DIRECTORY);
|
2007-07-12 18:33:32 -06:00
|
|
|
pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
|
2012-05-15 09:19:16 -06:00
|
|
|
pSMB->SearchFlags = cpu_to_le16(search_flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
|
|
|
|
|
|
|
|
/* BB what should we set StorageType to? Does it matter? BB */
|
|
|
|
pSMB->SearchStorageType = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_ffirst);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-09 15:21:45 -07:00
|
|
|
if (rc) {/* BB add logic to retry regular search if Unix search
|
|
|
|
rejected unexpectedly by server */
|
2005-04-16 16:20:36 -06:00
|
|
|
/* BB Add code to handle unsupported level rc */
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in FindFirst = %d", rc);
|
2005-08-17 13:38:22 -06:00
|
|
|
|
2006-03-09 15:21:45 -07:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* BB eventually could optimize out free and realloc of buf */
|
|
|
|
/* for this case */
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto findFirstRetry;
|
|
|
|
} else { /* decode response */
|
|
|
|
/* BB remember to free buffer if error BB */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == 0) {
|
2008-10-08 13:13:46 -06:00
|
|
|
unsigned int lnoff;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->unicode = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->unicode = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
psrch_inf->ntwrk_buf_start = (char *)pSMBr;
|
2006-02-27 20:45:48 -07:00
|
|
|
psrch_inf->smallBuf = 0;
|
2007-07-12 18:33:32 -06:00
|
|
|
psrch_inf->srch_entries_start =
|
|
|
|
(char *) &pSMBr->hdr.Protocol +
|
2005-04-16 16:20:36 -06:00
|
|
|
le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
|
|
|
|
le16_to_cpu(pSMBr->t2.ParameterOffset));
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (parms->EndofSearch)
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->endOfSearch = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->endOfSearch = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
psrch_inf->entries_in_buffer =
|
|
|
|
le16_to_cpu(parms->SearchCount);
|
2006-04-22 09:53:05 -06:00
|
|
|
psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
|
2005-04-16 16:20:36 -06:00
|
|
|
psrch_inf->entries_in_buffer;
|
2008-10-08 13:13:46 -06:00
|
|
|
lnoff = le16_to_cpu(parms->LastNameOffset);
|
2011-10-11 04:41:32 -06:00
|
|
|
if (CIFSMaxBufSize < lnoff) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "ignoring corrupt resume name");
|
2008-10-08 13:13:46 -06:00
|
|
|
psrch_inf->last_entry = NULL;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-10-07 14:03:33 -06:00
|
|
|
psrch_inf->last_entry = psrch_inf->srch_entries_start +
|
2008-10-08 13:13:46 -06:00
|
|
|
lnoff;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
*pnetfid = parms->SearchHandle;
|
|
|
|
} else {
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2012-05-15 09:19:16 -06:00
|
|
|
int CIFSFindNext(const int xid, struct cifs_tcon *tcon, __u16 searchHandle,
|
|
|
|
__u16 search_flags, struct cifs_search_info *psrch_inf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
TRANSACTION2_FNEXT_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
|
2008-02-07 16:25:02 -07:00
|
|
|
T2_FNEXT_RSP_PARMS *parms;
|
2005-04-16 16:20:36 -06:00
|
|
|
char *response_data;
|
|
|
|
int rc = 0;
|
2011-08-23 05:21:28 -06:00
|
|
|
int bytes_returned;
|
|
|
|
unsigned int name_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In FindNext");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-28 18:06:05 -06:00
|
|
|
if (psrch_inf->endOfSearch)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
params = 14; /* includes 2 bytes of null string, converted to LE below*/
|
2005-04-16 16:20:36 -06:00
|
|
|
byte_count = 0;
|
|
|
|
pSMB->TotalDataCount = 0; /* no EAs */
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(8);
|
2011-10-11 04:41:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(
|
|
|
|
offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
|
|
|
|
pSMB->SearchHandle = searchHandle; /* always kept as le */
|
|
|
|
pSMB->SearchCount =
|
2007-10-25 15:17:17 -06:00
|
|
|
cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
|
|
|
|
pSMB->ResumeKey = psrch_inf->resume_key;
|
2012-05-15 09:19:16 -06:00
|
|
|
pSMB->SearchFlags = cpu_to_le16(search_flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
name_len = psrch_inf->resume_name_len;
|
|
|
|
params += name_len;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (name_len < PATH_MAX) {
|
2005-04-16 16:20:36 -06:00
|
|
|
memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
|
|
|
|
byte_count += name_len;
|
2005-08-02 22:31:05 -06:00
|
|
|
/* 14 byte parm len above enough for 2 byte null terminator */
|
|
|
|
pSMB->ResumeFileName[name_len] = 0;
|
|
|
|
pSMB->ResumeFileName[name_len+1] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
rc = -EINVAL;
|
|
|
|
goto FNext2_err_exit;
|
|
|
|
}
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_fnext);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
|
|
|
if (rc == -EBADF) {
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->endOfSearch = true;
|
2008-05-12 20:56:05 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = 0; /* search probably was closed at end of search*/
|
2005-04-16 16:20:36 -06:00
|
|
|
} else
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "FindNext returned = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == 0) {
|
2008-10-08 13:13:46 -06:00
|
|
|
unsigned int lnoff;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* BB fixme add lock for file (srch_info) struct here */
|
|
|
|
if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->unicode = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->unicode = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
response_data = (char *) &pSMBr->hdr.Protocol +
|
|
|
|
le16_to_cpu(pSMBr->t2.ParameterOffset);
|
|
|
|
parms = (T2_FNEXT_RSP_PARMS *)response_data;
|
|
|
|
response_data = (char *)&pSMBr->hdr.Protocol +
|
|
|
|
le16_to_cpu(pSMBr->t2.DataOffset);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (psrch_inf->smallBuf)
|
2006-02-27 20:45:48 -07:00
|
|
|
cifs_small_buf_release(
|
|
|
|
psrch_inf->ntwrk_buf_start);
|
|
|
|
else
|
|
|
|
cifs_buf_release(psrch_inf->ntwrk_buf_start);
|
2005-04-16 16:20:36 -06:00
|
|
|
psrch_inf->srch_entries_start = response_data;
|
|
|
|
psrch_inf->ntwrk_buf_start = (char *)pSMB;
|
2006-02-27 20:45:48 -07:00
|
|
|
psrch_inf->smallBuf = 0;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (parms->EndofSearch)
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->endOfSearch = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-04-28 18:06:05 -06:00
|
|
|
psrch_inf->endOfSearch = false;
|
2007-07-12 18:33:32 -06:00
|
|
|
psrch_inf->entries_in_buffer =
|
|
|
|
le16_to_cpu(parms->SearchCount);
|
2005-04-16 16:20:36 -06:00
|
|
|
psrch_inf->index_of_last_entry +=
|
|
|
|
psrch_inf->entries_in_buffer;
|
2008-10-08 13:13:46 -06:00
|
|
|
lnoff = le16_to_cpu(parms->LastNameOffset);
|
2011-10-11 04:41:32 -06:00
|
|
|
if (CIFSMaxBufSize < lnoff) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "ignoring corrupt resume name");
|
2008-10-08 13:13:46 -06:00
|
|
|
psrch_inf->last_entry = NULL;
|
|
|
|
return rc;
|
|
|
|
} else
|
|
|
|
psrch_inf->last_entry =
|
|
|
|
psrch_inf->srch_entries_start + lnoff;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
/* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
|
|
|
|
psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* BB fixme add unlock here */
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* BB On error, should we leave previous search buf (and count and
|
|
|
|
last entry fields) intact or free the previous one? */
|
|
|
|
|
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
|
|
|
since file handle passed in no longer valid */
|
|
|
|
FNext2_err_exit:
|
|
|
|
if (rc != 0)
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSFindClose(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const __u16 searchHandle)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
FINDCLOSE_REQ *pSMB = NULL;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In CIFSSMBFindClose");
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
|
|
|
|
|
|
|
|
/* no sense returning error if session restarted
|
|
|
|
as file handle has been closed */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (rc == -EAGAIN)
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->FileID = searchHandle;
|
|
|
|
pSMB->ByteCount = 0;
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in FindClose = %d", rc);
|
2008-02-07 16:25:02 -07:00
|
|
|
|
2005-08-24 14:59:35 -06:00
|
|
|
cifs_stats_inc(&tcon->num_fclose);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Since session is dead, search handle closed on server already */
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
|
2007-07-12 18:33:32 -06:00
|
|
|
const unsigned char *searchName,
|
2008-02-07 16:25:02 -07:00
|
|
|
__u64 *inode_number,
|
2007-07-12 18:33:32 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int name_len, bytes_returned;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In GetSrvInodeNum for %s", searchName);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (tcon == NULL)
|
2007-07-12 18:33:32 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
GetInodeNumberRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
2007-07-12 18:33:32 -06:00
|
|
|
(void **) &pSMBr);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName,
|
|
|
|
searchName, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find exact max data count below from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4000);
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "error %d in QueryInternalInfo", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
/* BB also check enough total bytes returned */
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 2)
|
2005-04-16 16:20:36 -06:00
|
|
|
/* If rc should we check for EOPNOSUPP and
|
|
|
|
disable the srvino flag? or in caller? */
|
|
|
|
rc = -EIO; /* bad smb */
|
2007-07-12 18:33:32 -06:00
|
|
|
else {
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
__u16 count = le16_to_cpu(pSMBr->t2.DataCount);
|
2007-07-12 18:33:32 -06:00
|
|
|
struct file_internal_info *pfinfo;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* BB Do we need a cast or hash here ? */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (count < 8) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Illegal size ret in QryIntrnlInf");
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO;
|
|
|
|
goto GetInodeNumOut;
|
|
|
|
}
|
|
|
|
pfinfo = (struct file_internal_info *)
|
|
|
|
(data_offset + (char *) &pSMBr->hdr.Protocol);
|
2009-03-31 23:22:00 -06:00
|
|
|
*inode_number = le64_to_cpu(pfinfo->UniqueId);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
GetInodeNumOut:
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto GetInodeNumberRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-05-16 03:06:30 -06:00
|
|
|
/* parses DFS refferal V3 structure
|
|
|
|
* caller is responsible for freeing target_nodes
|
|
|
|
* returns:
|
|
|
|
* on success - 0
|
|
|
|
* on failure - errno
|
|
|
|
*/
|
|
|
|
static int
|
2008-05-16 12:48:38 -06:00
|
|
|
parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
|
2008-05-16 03:06:30 -06:00
|
|
|
unsigned int *num_of_nodes,
|
|
|
|
struct dfs_info3_param **target_nodes,
|
2008-10-23 03:58:42 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap,
|
|
|
|
const char *searchName)
|
2008-05-16 03:06:30 -06:00
|
|
|
{
|
|
|
|
int i, rc = 0;
|
|
|
|
char *data_end;
|
|
|
|
bool is_unicode;
|
|
|
|
struct dfs_referral_level_3 *ref;
|
|
|
|
|
2008-07-23 18:45:58 -06:00
|
|
|
if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
|
|
|
|
is_unicode = true;
|
|
|
|
else
|
|
|
|
is_unicode = false;
|
2008-05-16 03:06:30 -06:00
|
|
|
*num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
|
|
|
|
|
|
|
|
if (*num_of_nodes < 1) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "num_referrals: must be at least > 0,"
|
2012-07-23 11:14:28 -06:00
|
|
|
"but we get num_referrals = %d", *num_of_nodes);
|
2008-05-16 03:06:30 -06:00
|
|
|
rc = -EINVAL;
|
2008-05-16 12:48:38 -06:00
|
|
|
goto parse_DFS_referrals_exit;
|
2008-05-16 03:06:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
|
2008-06-02 03:59:02 -06:00
|
|
|
if (ref->VersionNumber != cpu_to_le16(3)) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Referrals of V%d version are not supported,"
|
|
|
|
"should be V3", le16_to_cpu(ref->VersionNumber));
|
2008-05-16 03:06:30 -06:00
|
|
|
rc = -EINVAL;
|
2008-05-16 12:48:38 -06:00
|
|
|
goto parse_DFS_referrals_exit;
|
2008-05-16 03:06:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* get the upper boundary of the resp buffer */
|
|
|
|
data_end = (char *)(&(pSMBr->PathConsumed)) +
|
|
|
|
le16_to_cpu(pSMBr->t2.DataCount);
|
|
|
|
|
2012-07-23 11:14:28 -06:00
|
|
|
cFYI(1, "num_referrals: %d dfs flags: 0x%x ...",
|
2008-05-16 03:06:30 -06:00
|
|
|
*num_of_nodes,
|
2010-04-20 21:50:45 -06:00
|
|
|
le32_to_cpu(pSMBr->DFSFlags));
|
2008-05-16 03:06:30 -06:00
|
|
|
|
|
|
|
*target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
|
|
|
|
*num_of_nodes, GFP_KERNEL);
|
|
|
|
if (*target_nodes == NULL) {
|
2012-07-23 11:14:28 -06:00
|
|
|
cERROR(1, "Failed to allocate buffer for target_nodes");
|
2008-05-16 03:06:30 -06:00
|
|
|
rc = -ENOMEM;
|
2008-05-16 12:48:38 -06:00
|
|
|
goto parse_DFS_referrals_exit;
|
2008-05-16 03:06:30 -06:00
|
|
|
}
|
|
|
|
|
tree-wide: Assorted spelling fixes
In particular, several occurances of funny versions of 'success',
'unknown', 'therefore', 'acknowledge', 'argument', 'achieve', 'address',
'beginning', 'desirable', 'separate' and 'necessary' are fixed.
Signed-off-by: Daniel Mack <daniel@caiaq.de>
Cc: Joe Perches <joe@perches.com>
Cc: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2010-02-02 17:01:28 -07:00
|
|
|
/* collect necessary data from referrals */
|
2008-05-16 03:06:30 -06:00
|
|
|
for (i = 0; i < *num_of_nodes; i++) {
|
|
|
|
char *temp;
|
|
|
|
int max_len;
|
|
|
|
struct dfs_info3_param *node = (*target_nodes)+i;
|
|
|
|
|
2009-04-30 23:27:32 -06:00
|
|
|
node->flags = le32_to_cpu(pSMBr->DFSFlags);
|
2008-10-23 03:58:42 -06:00
|
|
|
if (is_unicode) {
|
2008-12-17 04:31:53 -07:00
|
|
|
__le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
|
|
|
|
GFP_KERNEL);
|
2009-08-31 09:27:26 -06:00
|
|
|
if (tmp == NULL) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto parse_DFS_referrals_exit;
|
|
|
|
}
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) tmp, searchName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
|
|
|
node->path_consumed = cifs_utf16_bytes(tmp,
|
2009-04-30 04:46:32 -06:00
|
|
|
le16_to_cpu(pSMBr->PathConsumed),
|
2008-10-23 03:58:42 -06:00
|
|
|
nls_codepage);
|
|
|
|
kfree(tmp);
|
|
|
|
} else
|
|
|
|
node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
|
|
|
|
|
2008-05-16 03:06:30 -06:00
|
|
|
node->server_type = le16_to_cpu(ref->ServerType);
|
|
|
|
node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
|
|
|
|
|
|
|
|
/* copy DfsPath */
|
|
|
|
temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
|
|
|
|
max_len = data_end - temp;
|
2012-01-18 21:32:33 -07:00
|
|
|
node->path_name = cifs_strndup_from_utf16(temp, max_len,
|
|
|
|
is_unicode, nls_codepage);
|
2009-05-14 05:46:59 -06:00
|
|
|
if (!node->path_name) {
|
|
|
|
rc = -ENOMEM;
|
2008-05-16 12:48:38 -06:00
|
|
|
goto parse_DFS_referrals_exit;
|
2009-04-30 05:16:14 -06:00
|
|
|
}
|
2008-05-16 03:06:30 -06:00
|
|
|
|
|
|
|
/* copy link target UNC */
|
|
|
|
temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
|
|
|
|
max_len = data_end - temp;
|
2012-01-18 21:32:33 -07:00
|
|
|
node->node_name = cifs_strndup_from_utf16(temp, max_len,
|
|
|
|
is_unicode, nls_codepage);
|
2012-05-03 16:19:28 -06:00
|
|
|
if (!node->node_name) {
|
2009-05-14 05:46:59 -06:00
|
|
|
rc = -ENOMEM;
|
2012-05-03 16:19:28 -06:00
|
|
|
goto parse_DFS_referrals_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
ref++;
|
2008-05-16 03:06:30 -06:00
|
|
|
}
|
|
|
|
|
2008-05-16 12:48:38 -06:00
|
|
|
parse_DFS_referrals_exit:
|
2008-05-16 03:06:30 -06:00
|
|
|
if (rc) {
|
|
|
|
free_dfs_info_array(*target_nodes, *num_of_nodes);
|
|
|
|
*target_nodes = NULL;
|
|
|
|
*num_of_nodes = 0;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
|
2005-04-16 16:20:36 -06:00
|
|
|
const unsigned char *searchName,
|
2008-05-15 00:20:02 -06:00
|
|
|
struct dfs_info3_param **target_nodes,
|
|
|
|
unsigned int *num_of_nodes,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* TRANS2_GET_DFS_REFERRAL */
|
|
|
|
TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
__u16 params, byte_count;
|
2008-05-15 00:20:02 -06:00
|
|
|
*num_of_nodes = 0;
|
|
|
|
*target_nodes = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In GetDFSRefer the path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ses == NULL)
|
|
|
|
return -ENODEV;
|
|
|
|
getDFSRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
2007-07-12 18:33:32 -06:00
|
|
|
|
|
|
|
/* server pointer checked in called function,
|
2005-08-17 13:38:22 -06:00
|
|
|
but should never be null here anyway */
|
2012-05-23 04:01:59 -06:00
|
|
|
pSMB->hdr.Mid = get_next_mid(ses->server);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->hdr.Tid = ses->ipc_tid;
|
|
|
|
pSMB->hdr.Uid = ses->Suid;
|
2007-08-30 16:09:15 -06:00
|
|
|
if (ses->capabilities & CAP_STATUS32)
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
|
2007-08-30 16:09:15 -06:00
|
|
|
if (ses->capabilities & CAP_DFS)
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_DFS;
|
|
|
|
|
|
|
|
if (ses->capabilities & CAP_UNICODE) {
|
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
|
|
|
|
searchName, PATH_MAX, nls_codepage,
|
|
|
|
remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(searchName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->RequestFileName, searchName, name_len);
|
|
|
|
}
|
|
|
|
|
2007-07-07 13:25:05 -06:00
|
|
|
if (ses->server) {
|
2011-05-26 22:34:02 -06:00
|
|
|
if (ses->server->sec_mode &
|
2006-10-12 15:33:51 -06:00
|
|
|
(SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
|
|
|
|
pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
|
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
pSMB->hdr.Uid = ses->Suid;
|
2006-10-12 15:33:51 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
params = 2 /* level */ + name_len /*includes null */ ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->MaxParameterCount = 0;
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
|
|
|
|
byte_count = params + 3 /* pad */ ;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->MaxReferralLevel = cpu_to_le16(3);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in GetDFSRefer = %d", rc);
|
2008-05-15 00:20:02 -06:00
|
|
|
goto GetDFSRefExit;
|
|
|
|
}
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-15 00:20:02 -06:00
|
|
|
/* BB Also check if enough total bytes returned? */
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 17) {
|
2008-05-15 00:20:02 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
2008-05-16 03:06:30 -06:00
|
|
|
goto GetDFSRefExit;
|
|
|
|
}
|
2008-05-15 00:20:02 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
|
2011-05-04 06:05:26 -06:00
|
|
|
get_bcc(&pSMBr->hdr),
|
2010-04-20 21:50:45 -06:00
|
|
|
le16_to_cpu(pSMBr->t2.DataOffset));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-16 03:06:30 -06:00
|
|
|
/* parse returned result into more usable form */
|
2008-05-16 12:48:38 -06:00
|
|
|
rc = parse_DFS_referrals(pSMBr, num_of_nodes,
|
2008-10-23 03:58:42 -06:00
|
|
|
target_nodes, nls_codepage, remap,
|
|
|
|
searchName);
|
2008-05-15 00:20:02 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
GetDFSRefExit:
|
2008-05-21 20:02:03 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto getDFSRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-09-21 23:05:57 -06:00
|
|
|
/* Query File System Info such as free space to old servers such as Win 9x */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
|
2005-09-21 23:05:57 -06:00
|
|
|
{
|
|
|
|
/* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_ALLOC_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "OldQFSInfo");
|
2005-09-21 23:05:57 -06:00
|
|
|
oldQFSInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
|
|
|
struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-09-21 23:05:57 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QFSInfo = %d", rc);
|
2005-09-21 23:05:57 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 18)
|
2005-09-21 23:05:57 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "qfsinf resp BCC: %d Offset %d",
|
2011-05-04 06:05:26 -06:00
|
|
|
get_bcc(&pSMBr->hdr), data_offset);
|
2005-09-21 23:05:57 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
response_data = (FILE_SYSTEM_ALLOC_INFO *)
|
2005-09-21 23:05:57 -06:00
|
|
|
(((char *) &pSMBr->hdr.Protocol) + data_offset);
|
|
|
|
FSData->f_bsize =
|
|
|
|
le16_to_cpu(response_data->BytesPerSector) *
|
|
|
|
le32_to_cpu(response_data->
|
|
|
|
SectorsPerAllocationUnit);
|
|
|
|
FSData->f_blocks =
|
2007-07-12 18:33:32 -06:00
|
|
|
le32_to_cpu(response_data->TotalAllocationUnits);
|
2005-09-21 23:05:57 -06:00
|
|
|
FSData->f_bfree = FSData->f_bavail =
|
|
|
|
le32_to_cpu(response_data->FreeAllocationUnits);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
|
|
|
|
(unsigned long long)FSData->f_blocks,
|
|
|
|
(unsigned long long)FSData->f_bfree,
|
|
|
|
FSData->f_bsize);
|
2005-09-21 23:05:57 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto oldQFSInfoRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QFSInfo");
|
2005-04-16 16:20:36 -06:00
|
|
|
QFSInfoRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2005-09-21 23:05:57 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QFSInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
2007-07-12 18:33:32 -06:00
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 24)
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
|
|
|
|
response_data =
|
|
|
|
(FILE_SYSTEM_INFO
|
|
|
|
*) (((char *) &pSMBr->hdr.Protocol) +
|
|
|
|
data_offset);
|
|
|
|
FSData->f_bsize =
|
|
|
|
le32_to_cpu(response_data->BytesPerSector) *
|
|
|
|
le32_to_cpu(response_data->
|
|
|
|
SectorsPerAllocationUnit);
|
|
|
|
FSData->f_blocks =
|
|
|
|
le64_to_cpu(response_data->TotalAllocationUnits);
|
|
|
|
FSData->f_bfree = FSData->f_bavail =
|
|
|
|
le64_to_cpu(response_data->FreeAllocationUnits);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
|
|
|
|
(unsigned long long)FSData->f_blocks,
|
|
|
|
(unsigned long long)FSData->f_bfree,
|
|
|
|
FSData->f_bsize);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFSInfoRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QFSAttributeInfo");
|
2005-04-16 16:20:36 -06:00
|
|
|
QFSAttributeRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 13) {
|
2007-07-12 18:33:32 -06:00
|
|
|
/* BB also check if enough bytes returned */
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
} else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
response_data =
|
|
|
|
(FILE_SYSTEM_ATTRIBUTE_INFO
|
|
|
|
*) (((char *) &pSMBr->hdr.Protocol) +
|
|
|
|
data_offset);
|
|
|
|
memcpy(&tcon->fsAttrInfo, response_data,
|
2007-08-30 16:09:15 -06:00
|
|
|
sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFSAttributeRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_DEVICE_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QFSDeviceInfo");
|
2005-04-16 16:20:36 -06:00
|
|
|
QFSDeviceRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) <
|
|
|
|
sizeof(FILE_SYSTEM_DEVICE_INFO))
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
response_data =
|
2005-04-28 23:41:06 -06:00
|
|
|
(FILE_SYSTEM_DEVICE_INFO *)
|
|
|
|
(((char *) &pSMBr->hdr.Protocol) +
|
2005-04-16 16:20:36 -06:00
|
|
|
data_offset);
|
|
|
|
memcpy(&tcon->fsDevInfo, response_data,
|
2007-08-30 16:09:15 -06:00
|
|
|
sizeof(FILE_SYSTEM_DEVICE_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFSDeviceRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_UNIX_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QFSUnixInfo");
|
2005-04-16 16:20:36 -06:00
|
|
|
QFSUnixRetry:
|
2010-09-29 13:27:08 -06:00
|
|
|
rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
|
|
|
|
(void **) &pSMB, (void **) &pSMBr);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(100);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
2007-07-12 18:33:32 -06:00
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
|
|
|
|
smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in QFSUnixInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 13) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
} else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
response_data =
|
|
|
|
(FILE_SYSTEM_UNIX_INFO
|
|
|
|
*) (((char *) &pSMBr->hdr.Protocol) +
|
|
|
|
data_offset);
|
|
|
|
memcpy(&tcon->fsUnixInfo, response_data,
|
2007-08-30 16:09:15 -06:00
|
|
|
sizeof(FILE_SYSTEM_UNIX_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFSUnixRetry;
|
|
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-06-22 18:26:35 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
|
2005-06-22 18:26:35 -06:00
|
|
|
{
|
|
|
|
/* level 0x200 SMB_SET_CIFS_UNIX_INFO */
|
|
|
|
TRANSACTION2_SETFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SETFSUnixInfo");
|
2005-06-22 18:26:35 -06:00
|
|
|
SETFSUnixRetry:
|
2006-03-01 02:17:37 -07:00
|
|
|
/* BB switch to small buf init to save memory */
|
2010-09-29 13:27:08 -06:00
|
|
|
rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
|
|
|
|
(void **) &pSMB, (void **) &pSMBr);
|
2005-06-22 18:26:35 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 4; /* 2 bytes zero followed by info level. */
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
2007-07-12 18:33:32 -06:00
|
|
|
param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
|
|
|
|
- 4;
|
2005-06-22 18:26:35 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(4);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(100);
|
2005-06-22 18:26:35 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
|
|
|
|
byte_count = 1 /* pad */ + params + 12;
|
|
|
|
|
|
|
|
pSMB->DataCount = cpu_to_le16(12);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
|
|
|
|
/* Params. */
|
|
|
|
pSMB->FileNum = 0;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
|
|
|
|
|
|
|
|
/* Data. */
|
|
|
|
pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
|
|
|
|
pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
|
|
|
|
pSMB->ClientUnixCap = cpu_to_le64(cap);
|
|
|
|
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-06-22 18:26:35 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
|
2005-06-22 18:26:35 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2005-06-22 18:26:35 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto SETFSUnixRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
|
2005-04-28 23:41:06 -06:00
|
|
|
struct kstatfs *FSData)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
|
|
|
|
TRANSACTION2_QFSI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QFSI_RSP *pSMBr = NULL;
|
|
|
|
FILE_SYSTEM_POSIX_INFO *response_data;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In QFSPosixInfo");
|
2005-04-16 16:20:36 -06:00
|
|
|
QFSPosixRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
params = 2; /* level */
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(100);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
2007-07-12 18:33:32 -06:00
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
|
|
|
|
smb_com_transaction2_qfsi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QFSUnixInfo = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* decode response */
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
|
|
|
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 13) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
} else {
|
|
|
|
__u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
response_data =
|
|
|
|
(FILE_SYSTEM_POSIX_INFO
|
|
|
|
*) (((char *) &pSMBr->hdr.Protocol) +
|
|
|
|
data_offset);
|
|
|
|
FSData->f_bsize =
|
|
|
|
le32_to_cpu(response_data->BlockSize);
|
|
|
|
FSData->f_blocks =
|
|
|
|
le64_to_cpu(response_data->TotalBlocks);
|
|
|
|
FSData->f_bfree =
|
|
|
|
le64_to_cpu(response_data->BlocksAvail);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
FSData->f_bavail = FSData->f_bfree;
|
|
|
|
} else {
|
|
|
|
FSData->f_bavail =
|
2007-07-12 18:33:32 -06:00
|
|
|
le64_to_cpu(response_data->UserBlocksAvail);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-07 13:25:05 -06:00
|
|
|
if (response_data->TotalFileNodes != cpu_to_le64(-1))
|
2005-04-16 16:20:36 -06:00
|
|
|
FSData->f_files =
|
2007-07-12 18:33:32 -06:00
|
|
|
le64_to_cpu(response_data->TotalFileNodes);
|
2007-07-07 13:25:05 -06:00
|
|
|
if (response_data->FreeFileNodes != cpu_to_le64(-1))
|
2005-04-16 16:20:36 -06:00
|
|
|
FSData->f_ffree =
|
2007-07-12 18:33:32 -06:00
|
|
|
le64_to_cpu(response_data->FreeFileNodes);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QFSPosixRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* We can not use write of zero bytes trick to
|
|
|
|
set file size due to need for large file support. Also note that
|
|
|
|
this SetPathInfo is preferred to SetFileInfo based method in next
|
2005-04-16 16:20:36 -06:00
|
|
|
routine which is only needed to work around a sharing violation bug
|
|
|
|
in Samba which this routine can run into */
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
|
2008-04-28 18:06:05 -06:00
|
|
|
__u64 size, bool SetAllocation,
|
2005-04-28 23:41:06 -06:00
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_spi_req *pSMB = NULL;
|
|
|
|
struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
|
|
|
|
struct file_end_of_file_info *parm_data;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, byte_count, data_count, param_offset, offset;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetEOF");
|
2005-04-16 16:20:36 -06:00
|
|
|
SetEOFRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2005-09-18 21:49:21 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
params = 6 + name_len;
|
2007-08-30 16:09:15 -06:00
|
|
|
data_count = sizeof(struct file_end_of_file_info);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2005-09-18 21:49:21 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(4100);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (SetAllocation) {
|
2007-07-12 18:33:32 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
|
|
|
|
else
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
|
|
|
|
} else /* Set File Size */ {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
pSMB->InformationLevel =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
parm_data =
|
|
|
|
(struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
|
|
|
|
offset);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + data_count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(data_count);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
parm_data->FileSize = cpu_to_le64(size);
|
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetPathInfo (file size) returned %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto SetEOFRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
|
2008-04-28 18:06:05 -06:00
|
|
|
__u16 fid, __u32 pid_of_opener, bool SetAllocation)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
|
|
|
struct file_end_of_file_info *parm_data;
|
|
|
|
int rc = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetFileSize (via SetFileInfo) %lld",
|
|
|
|
(long long)size);
|
2005-04-28 23:41:10 -06:00
|
|
|
rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
params = 6;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
count = sizeof(struct file_end_of_file_info);
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
parm_data =
|
2007-07-12 18:33:32 -06:00
|
|
|
(struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
|
|
|
|
+ offset);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
parm_data->FileSize = cpu_to_le64(size);
|
|
|
|
pSMB->Fid = fid;
|
2007-07-07 13:25:05 -06:00
|
|
|
if (SetAllocation) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
|
|
|
|
else
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
|
2007-07-12 18:33:32 -06:00
|
|
|
} else /* Set File Size */ {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
pSMB->InformationLevel =
|
2007-07-12 18:33:32 -06:00
|
|
|
cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Some legacy servers such as NT4 require that the file times be set on
|
2005-04-16 16:20:36 -06:00
|
|
|
an open handle, rather than by pathname - this is awkward due to
|
|
|
|
potential access conflicts on the open, but it is unavoidable for these
|
|
|
|
old servers since the only other choice is to go from 100 nanosecond DCE
|
|
|
|
time and resort to the original setpathinfo level which takes the ancient
|
|
|
|
DOS time format with 2 second granularity */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
|
2008-08-02 05:26:12 -06:00
|
|
|
const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
|
|
|
char *data_offset;
|
|
|
|
int rc = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Set Times (via SetFileInfo)");
|
2005-04-28 23:41:10 -06:00
|
|
|
rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
2008-08-02 05:26:12 -06:00
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
|
2007-07-12 18:33:32 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
params = 6;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
2012-03-26 07:55:29 -06:00
|
|
|
data_offset = (char *)pSMB +
|
|
|
|
offsetof(struct smb_hdr, Protocol) + offset;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-08-30 16:09:15 -06:00
|
|
|
count = sizeof(FILE_BASIC_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find max SMB PDU from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->Fid = fid;
|
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
|
|
|
|
else
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
2007-07-12 18:33:32 -06:00
|
|
|
memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
2005-04-16 16:20:36 -06:00
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-09-23 09:48:35 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
|
2008-09-23 09:48:35 -06:00
|
|
|
bool delete_file, __u16 fid, __u32 pid_of_opener)
|
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
|
|
|
char *data_offset;
|
|
|
|
int rc = 0;
|
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Set File Disposition (via SetFileInfo)");
|
2008-09-23 09:48:35 -06:00
|
|
|
rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
|
|
|
|
|
|
|
|
params = 6;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
|
|
|
data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
|
|
|
|
|
|
|
|
count = 1;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find max SMB PDU from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->Fid = fid;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2008-09-23 09:48:35 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
*data_offset = delete_file ? 1 : 0;
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2008-09-23 09:48:35 -06:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in SetFileDisposition = %d", rc);
|
2008-09-23 09:48:35 -06:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
|
2008-08-02 05:26:12 -06:00
|
|
|
const char *fileName, const FILE_BASIC_INFO *data,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
char *data_offset;
|
|
|
|
__u16 params, param_offset, offset, byte_count, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetTimes");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
SetTimesRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 6 + name_len;
|
2007-08-30 16:09:15 -06:00
|
|
|
count = sizeof(FILE_BASIC_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
|
|
|
|
else
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2007-08-30 16:09:15 -06:00
|
|
|
memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetPathInfo (times) returned %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto SetTimesRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Can not be used to set time stamps yet (due to old DOS time format) */
|
|
|
|
/* Can be used to set attributes */
|
|
|
|
#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
|
|
|
|
handling it anyway and NT4 was what we thought it would be needed for
|
|
|
|
Do not delete it until we prove whether needed for Win9x though */
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 dos_attrs, const struct nls_table *nls_codepage)
|
|
|
|
{
|
|
|
|
SETATTR_REQ *pSMB = NULL;
|
|
|
|
SETATTR_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
|
|
|
int name_len;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetAttrLegacy");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
SetAttrLgcyRetry:
|
|
|
|
rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->fileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
pSMB->attr = cpu_to_le16(dos_attrs);
|
|
|
|
pSMB->BufferFormat = 0x04;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, name_len + 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(name_len + 1);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Error in LegacySetAttr = %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto SetAttrLgcyRetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
#endif /* temporarily unneeded SetAttr legacy function */
|
|
|
|
|
2009-07-09 18:02:49 -06:00
|
|
|
static void
|
|
|
|
cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
|
|
|
|
const struct cifs_unix_set_info_args *args)
|
|
|
|
{
|
|
|
|
u64 mode = args->mode;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Samba server ignores set of file size to zero due to bugs in some
|
|
|
|
* older clients, but we should be precise - we use SetFileSize to
|
|
|
|
* set file size and do not want to truncate file size to zero
|
2011-03-30 19:57:33 -06:00
|
|
|
* accidentally as happened on one Samba server beta by putting
|
2009-07-09 18:02:49 -06:00
|
|
|
* zero instead of -1 here
|
|
|
|
*/
|
|
|
|
data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
|
|
|
|
data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
|
|
|
|
data_offset->LastStatusChange = cpu_to_le64(args->ctime);
|
|
|
|
data_offset->LastAccessTime = cpu_to_le64(args->atime);
|
|
|
|
data_offset->LastModificationTime = cpu_to_le64(args->mtime);
|
|
|
|
data_offset->Uid = cpu_to_le64(args->uid);
|
|
|
|
data_offset->Gid = cpu_to_le64(args->gid);
|
|
|
|
/* better to leave device as zero when it is */
|
|
|
|
data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
|
|
|
|
data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
|
|
|
|
data_offset->Permissions = cpu_to_le64(mode);
|
|
|
|
|
|
|
|
if (S_ISREG(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_FILE);
|
|
|
|
else if (S_ISDIR(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_DIR);
|
|
|
|
else if (S_ISLNK(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
|
|
|
|
else if (S_ISCHR(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
|
|
|
|
else if (S_ISBLK(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
|
|
|
|
else if (S_ISFIFO(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_FIFO);
|
|
|
|
else if (S_ISSOCK(mode))
|
|
|
|
data_offset->Type = cpu_to_le32(UNIX_SOCKET);
|
|
|
|
}
|
|
|
|
|
2009-07-09 18:02:50 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
|
2009-07-09 18:02:50 -06:00
|
|
|
const struct cifs_unix_set_info_args *args,
|
|
|
|
u16 fid, u32 pid_of_opener)
|
|
|
|
{
|
|
|
|
struct smb_com_transaction2_sfi_req *pSMB = NULL;
|
2012-03-26 07:55:29 -06:00
|
|
|
char *data_offset;
|
2009-07-09 18:02:50 -06:00
|
|
|
int rc = 0;
|
|
|
|
u16 params, param_offset, offset, byte_count, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Set Unix Info (via SetFileInfo)");
|
2009-07-09 18:02:50 -06:00
|
|
|
rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
|
|
|
|
pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
|
|
|
|
|
|
|
|
params = 6;
|
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
|
|
|
|
offset = param_offset + params;
|
|
|
|
|
2012-03-26 07:55:29 -06:00
|
|
|
data_offset = (char *)pSMB +
|
|
|
|
offsetof(struct smb_hdr, Protocol) + offset;
|
|
|
|
|
2009-07-09 18:02:50 -06:00
|
|
|
count = sizeof(FILE_UNIX_BASIC_INFO);
|
|
|
|
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
|
|
|
/* BB find max SMB PDU from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->Fid = fid;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2009-07-09 18:02:50 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
2012-03-26 07:55:29 -06:00
|
|
|
cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
|
2009-07-09 18:02:50 -06:00
|
|
|
|
2012-03-23 12:28:02 -06:00
|
|
|
rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
|
2009-07-09 18:02:50 -06:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
|
2009-07-09 18:02:50 -06:00
|
|
|
|
|
|
|
/* Note: On -EAGAIN error only caller can retry on handle based calls
|
|
|
|
since file handle passed in no longer valid */
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
|
2009-07-09 18:02:49 -06:00
|
|
|
const struct cifs_unix_set_info_args *args,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
TRANSACTION2_SPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_SPI_RSP *pSMBr = NULL;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
FILE_UNIX_BASIC_INFO *data_offset;
|
|
|
|
__u16 params, param_offset, offset, count, byte_count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetUID/GID/Mode");
|
2005-04-16 16:20:36 -06:00
|
|
|
setPermsRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2005-09-18 21:49:21 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 6 + name_len;
|
2007-08-30 16:09:15 -06:00
|
|
|
count = sizeof(FILE_UNIX_BASIC_INFO);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find max SMB PDU from sess structure BB */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
data_offset =
|
|
|
|
(FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
|
|
|
|
offset);
|
|
|
|
memset(data_offset, 0, count);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-09 18:02:49 -06:00
|
|
|
cifs_fill_unix_set_info(data_offset, args);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetPathInfo (perms) returned %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-21 20:02:03 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto setPermsRetry;
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_CIFS_XATTR
|
2010-02-10 14:18:26 -07:00
|
|
|
/*
|
|
|
|
* Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
|
|
|
|
* function used by listxattr and getxattr type calls. When ea_name is set,
|
|
|
|
* it looks for that attribute name and stuffs that value into the EAData
|
|
|
|
* buffer. When ea_name is NULL, it stuffs a list of attribute names into the
|
|
|
|
* buffer. In both cases, the return value is either the length of the
|
|
|
|
* resulting data or a negative error code. If EAData is a NULL pointer then
|
|
|
|
* the data isn't copied to it, but the length is returned.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
ssize_t
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
|
2010-02-10 14:18:26 -07:00
|
|
|
const unsigned char *searchName, const unsigned char *ea_name,
|
|
|
|
char *EAData, size_t buf_size,
|
|
|
|
const struct nls_table *nls_codepage, int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* BB assumes one setup word */
|
|
|
|
TRANSACTION2_QPI_REQ *pSMB = NULL;
|
|
|
|
TRANSACTION2_QPI_RSP *pSMBr = NULL;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned;
|
2010-02-10 14:18:26 -07:00
|
|
|
int list_len;
|
2010-02-10 14:18:26 -07:00
|
|
|
struct fealist *ea_response_data;
|
2007-07-12 18:33:32 -06:00
|
|
|
struct fea *temp_fea;
|
|
|
|
char *temp_ptr;
|
2010-02-10 14:18:26 -07:00
|
|
|
char *end_of_smb;
|
2010-02-10 14:18:26 -07:00
|
|
|
__u16 params, byte_count, data_offset;
|
2011-07-28 10:48:26 -06:00
|
|
|
unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In Query All EAs path %s", searchName);
|
2005-04-16 16:20:36 -06:00
|
|
|
QAllEAsRetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len++; /* trailing null */
|
|
|
|
list_len *= 2;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len = strnlen(searchName, PATH_MAX);
|
|
|
|
list_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, searchName, list_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find exact max SMB PDU from sess structure BB */
|
2010-02-10 14:18:26 -07:00
|
|
|
pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(offsetof(
|
2007-07-12 18:33:32 -06:00
|
|
|
struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
|
|
|
|
byte_count = params + 1 /* pad */ ;
|
|
|
|
pSMB->TotalParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
|
|
|
if (rc) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "Send error in QueryAllEAs = %d", rc);
|
2010-02-10 14:18:26 -07:00
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
|
|
|
|
/* BB also check enough total bytes returned */
|
|
|
|
/* BB we need to improve the validity checking
|
|
|
|
of these trans2 responses */
|
|
|
|
|
|
|
|
rc = validate_t2((struct smb_t2_rsp *)pSMBr);
|
2011-05-04 06:05:26 -06:00
|
|
|
if (rc || get_bcc(&pSMBr->hdr) < 4) {
|
2010-02-10 14:18:26 -07:00
|
|
|
rc = -EIO; /* bad smb */
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check that length of list is not more than bcc */
|
|
|
|
/* check that each entry does not go beyond length
|
|
|
|
of list */
|
|
|
|
/* check that each element of each entry does not
|
|
|
|
go beyond end of list */
|
|
|
|
/* validate_trans2_offsets() */
|
|
|
|
/* BB check if start of smb + data_offset > &bcc+ bcc */
|
|
|
|
|
|
|
|
data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
|
|
|
|
ea_response_data = (struct fealist *)
|
|
|
|
(((char *) &pSMBr->hdr.Protocol) + data_offset);
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len = le32_to_cpu(ea_response_data->list_len);
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "ea length %d", list_len);
|
2010-02-10 14:18:26 -07:00
|
|
|
if (list_len <= 8) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "empty EA list returned from server");
|
2010-02-10 14:18:26 -07:00
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
/* make sure list_len doesn't go past end of SMB */
|
2011-01-20 11:36:51 -07:00
|
|
|
end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
|
2010-02-10 14:18:26 -07:00
|
|
|
if ((char *)ea_response_data + list_len > end_of_smb) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "EA list appears to go beyond SMB");
|
2010-02-10 14:18:26 -07:00
|
|
|
rc = -EIO;
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
/* account for ea list len */
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len -= 4;
|
2010-02-10 14:18:26 -07:00
|
|
|
temp_fea = ea_response_data->list;
|
|
|
|
temp_ptr = (char *)temp_fea;
|
2010-02-10 14:18:26 -07:00
|
|
|
while (list_len > 0) {
|
2010-02-24 14:56:48 -07:00
|
|
|
unsigned int name_len;
|
2010-02-10 14:18:26 -07:00
|
|
|
__u16 value_len;
|
2010-02-10 14:18:26 -07:00
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
list_len -= 4;
|
2010-02-10 14:18:26 -07:00
|
|
|
temp_ptr += 4;
|
2010-02-10 14:18:26 -07:00
|
|
|
/* make sure we can read name_len and value_len */
|
|
|
|
if (list_len < 0) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "EA entry goes beyond length of list");
|
2010-02-10 14:18:26 -07:00
|
|
|
rc = -EIO;
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
|
|
|
|
name_len = temp_fea->name_len;
|
|
|
|
value_len = le16_to_cpu(temp_fea->value_len);
|
|
|
|
list_len -= name_len + 1 + value_len;
|
|
|
|
if (list_len < 0) {
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "EA entry goes beyond length of list");
|
2010-02-10 14:18:26 -07:00
|
|
|
rc = -EIO;
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
if (ea_name) {
|
2011-07-26 16:23:47 -06:00
|
|
|
if (ea_name_len == name_len &&
|
2011-10-11 04:41:32 -06:00
|
|
|
memcmp(ea_name, temp_ptr, name_len) == 0) {
|
2010-02-10 14:18:26 -07:00
|
|
|
temp_ptr += name_len + 1;
|
|
|
|
rc = value_len;
|
|
|
|
if (buf_size == 0)
|
|
|
|
goto QAllEAsOut;
|
|
|
|
if ((size_t)value_len > buf_size) {
|
|
|
|
rc = -ERANGE;
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
|
|
|
memcpy(EAData, temp_ptr, value_len);
|
|
|
|
goto QAllEAsOut;
|
|
|
|
}
|
2010-02-10 14:18:26 -07:00
|
|
|
} else {
|
2010-02-10 14:18:26 -07:00
|
|
|
/* account for prefix user. and trailing null */
|
|
|
|
rc += (5 + 1 + name_len);
|
|
|
|
if (rc < (int) buf_size) {
|
|
|
|
memcpy(EAData, "user.", 5);
|
|
|
|
EAData += 5;
|
|
|
|
memcpy(EAData, temp_ptr, name_len);
|
|
|
|
EAData += name_len;
|
|
|
|
/* null terminate name */
|
|
|
|
*EAData = 0;
|
|
|
|
++EAData;
|
|
|
|
} else if (buf_size == 0) {
|
|
|
|
/* skip copy - calc size only */
|
|
|
|
} else {
|
|
|
|
/* stop before overrun buffer */
|
|
|
|
rc = -ERANGE;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-02-10 14:18:26 -07:00
|
|
|
temp_ptr += name_len + 1 + value_len;
|
2010-02-10 14:18:26 -07:00
|
|
|
temp_fea = (struct fea *)temp_ptr;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-02-10 14:18:26 -07:00
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
/* didn't find the named attribute */
|
|
|
|
if (ea_name)
|
|
|
|
rc = -ENODATA;
|
|
|
|
|
2010-02-10 14:18:26 -07:00
|
|
|
QAllEAsOut:
|
2008-05-21 20:02:03 -06:00
|
|
|
cifs_buf_release(pSMB);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto QAllEAsRetry;
|
|
|
|
|
|
|
|
return (ssize_t)rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-26 22:34:02 -06:00
|
|
|
CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
|
2007-07-12 18:33:32 -06:00
|
|
|
const char *ea_name, const void *ea_value,
|
|
|
|
const __u16 ea_value_len, const struct nls_table *nls_codepage,
|
|
|
|
int remap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct smb_com_transaction2_spi_req *pSMB = NULL;
|
|
|
|
struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
|
|
|
|
struct fealist *parm_data;
|
|
|
|
int name_len;
|
|
|
|
int rc = 0;
|
|
|
|
int bytes_returned = 0;
|
|
|
|
__u16 params, param_offset, byte_count, offset, count;
|
|
|
|
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "In SetEA");
|
2005-04-16 16:20:36 -06:00
|
|
|
SetEARetry:
|
|
|
|
rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
|
|
|
|
name_len =
|
2012-01-18 21:32:33 -07:00
|
|
|
cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
|
|
|
|
PATH_MAX, nls_codepage, remap);
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len++; /* trailing null */
|
|
|
|
name_len *= 2;
|
2007-07-12 18:33:32 -06:00
|
|
|
} else { /* BB improve the check for buffer overruns BB */
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = strnlen(fileName, PATH_MAX);
|
|
|
|
name_len++; /* trailing null */
|
|
|
|
strncpy(pSMB->FileName, fileName, name_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
params = 6 + name_len;
|
|
|
|
|
|
|
|
/* done calculating parms using name_len of file name,
|
|
|
|
now use name_len to calculate length of ea name
|
|
|
|
we are going to create in the inode xattrs */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (ea_name == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
name_len = 0;
|
|
|
|
else
|
2007-07-12 18:33:32 -06:00
|
|
|
name_len = strnlen(ea_name, 255);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-30 16:49:57 -07:00
|
|
|
count = sizeof(*parm_data) + ea_value_len + name_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxParameterCount = cpu_to_le16(2);
|
2008-05-12 22:54:12 -06:00
|
|
|
/* BB find max SMB PDU from sess */
|
|
|
|
pSMB->MaxDataCount = cpu_to_le16(1000);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->MaxSetupCount = 0;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->Flags = 0;
|
|
|
|
pSMB->Timeout = 0;
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
param_offset = offsetof(struct smb_com_transaction2_spi_req,
|
2007-07-12 18:33:32 -06:00
|
|
|
InformationLevel) - 4;
|
2005-04-16 16:20:36 -06:00
|
|
|
offset = param_offset + params;
|
|
|
|
pSMB->InformationLevel =
|
|
|
|
cpu_to_le16(SMB_SET_FILE_EA);
|
|
|
|
|
|
|
|
parm_data =
|
|
|
|
(struct fealist *) (((char *) &pSMB->hdr.Protocol) +
|
|
|
|
offset);
|
|
|
|
pSMB->ParameterOffset = cpu_to_le16(param_offset);
|
|
|
|
pSMB->DataOffset = cpu_to_le16(offset);
|
|
|
|
pSMB->SetupCount = 1;
|
|
|
|
pSMB->Reserved3 = 0;
|
|
|
|
pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
|
|
|
|
byte_count = 3 /* pad */ + params + count;
|
|
|
|
pSMB->DataCount = cpu_to_le16(count);
|
|
|
|
parm_data->list_len = cpu_to_le32(count);
|
|
|
|
parm_data->list[0].EA_flags = 0;
|
|
|
|
/* we checked above that name len is less than 255 */
|
2006-03-24 04:16:13 -07:00
|
|
|
parm_data->list[0].name_len = (__u8)name_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* EA names are always ASCII */
|
2007-07-07 13:25:05 -06:00
|
|
|
if (ea_name)
|
2007-07-12 18:33:32 -06:00
|
|
|
strncpy(parm_data->list[0].name, ea_name, name_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
parm_data->list[0].name[name_len] = 0;
|
|
|
|
parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
|
|
|
|
/* caller ensures that ea_value_len is less than 64K but
|
|
|
|
we need to ensure that it fits within the smb */
|
|
|
|
|
2007-07-12 18:33:32 -06:00
|
|
|
/*BB add length check to see if it would fit in
|
|
|
|
negotiated SMB buffer size BB */
|
2007-07-07 13:25:05 -06:00
|
|
|
/* if (ea_value_len > buffer_size - 512 (enough for header)) */
|
|
|
|
if (ea_value_len)
|
2007-07-12 18:33:32 -06:00
|
|
|
memcpy(parm_data->list[0].name+name_len+1,
|
|
|
|
ea_value, ea_value_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pSMB->TotalDataCount = pSMB->DataCount;
|
|
|
|
pSMB->ParameterCount = cpu_to_le16(params);
|
|
|
|
pSMB->TotalParameterCount = pSMB->ParameterCount;
|
|
|
|
pSMB->Reserved4 = 0;
|
2011-04-28 23:40:20 -06:00
|
|
|
inc_rfc1001_len(pSMB, byte_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
pSMB->ByteCount = cpu_to_le16(byte_count);
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *) pSMBr, &bytes_returned, 0);
|
2008-02-07 16:25:02 -07:00
|
|
|
if (rc)
|
2010-04-20 21:50:45 -06:00
|
|
|
cFYI(1, "SetPathInfo (EA) returned %d", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
|
|
|
|
if (rc == -EAGAIN)
|
|
|
|
goto SetEARetry;
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
#endif
|
2011-02-23 22:39:23 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
|
|
|
|
/*
|
|
|
|
* Years ago the kernel added a "dnotify" function for Samba server,
|
|
|
|
* to allow network clients (such as Windows) to display updated
|
|
|
|
* lists of files in directory listings automatically when
|
|
|
|
* files are added by one user when another user has the
|
|
|
|
* same directory open on their desktop. The Linux cifs kernel
|
|
|
|
* client hooked into the kernel side of this interface for
|
|
|
|
* the same reason, but ironically when the VFS moved from
|
|
|
|
* "dnotify" to "inotify" it became harder to plug in Linux
|
|
|
|
* network file system clients (the most obvious use case
|
|
|
|
* for notify interfaces is when multiple users can update
|
|
|
|
* the contents of the same directory - exactly what network
|
|
|
|
* file systems can do) although the server (Samba) could
|
|
|
|
* still use it. For the short term we leave the worker
|
|
|
|
* function ifdeffed out (below) until inotify is fixed
|
|
|
|
* in the VFS to make it easier to plug in network file
|
|
|
|
* system clients. If inotify turns out to be permanently
|
|
|
|
* incompatible for network fs clients, we could instead simply
|
|
|
|
* expose this config flag by adding a future cifs (and smb2) notify ioctl.
|
|
|
|
*/
|
2011-05-26 22:34:02 -06:00
|
|
|
int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
|
2011-02-23 22:39:23 -07:00
|
|
|
const int notify_subdirs, const __u16 netfid,
|
|
|
|
__u32 filter, struct file *pfile, int multishot,
|
|
|
|
const struct nls_table *nls_codepage)
|
|
|
|
{
|
|
|
|
int rc = 0;
|
|
|
|
struct smb_com_transaction_change_notify_req *pSMB = NULL;
|
|
|
|
struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
|
|
|
|
struct dir_notify_req *dnotify_req;
|
|
|
|
int bytes_returned;
|
|
|
|
|
|
|
|
cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
|
|
|
|
rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
|
|
|
|
(void **) &pSMBr);
|
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
pSMB->TotalParameterCount = 0 ;
|
|
|
|
pSMB->TotalDataCount = 0;
|
|
|
|
pSMB->MaxParameterCount = cpu_to_le32(2);
|
2011-10-11 04:41:32 -06:00
|
|
|
pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
|
2011-02-23 22:39:23 -07:00
|
|
|
pSMB->MaxSetupCount = 4;
|
|
|
|
pSMB->Reserved = 0;
|
|
|
|
pSMB->ParameterOffset = 0;
|
|
|
|
pSMB->DataCount = 0;
|
|
|
|
pSMB->DataOffset = 0;
|
|
|
|
pSMB->SetupCount = 4; /* single byte does not need le conversion */
|
|
|
|
pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
|
|
|
|
pSMB->ParameterCount = pSMB->TotalParameterCount;
|
|
|
|
if (notify_subdirs)
|
|
|
|
pSMB->WatchTree = 1; /* one byte - no le conversion needed */
|
|
|
|
pSMB->Reserved2 = 0;
|
|
|
|
pSMB->CompletionFilter = cpu_to_le32(filter);
|
|
|
|
pSMB->Fid = netfid; /* file handle always le */
|
|
|
|
pSMB->ByteCount = 0;
|
|
|
|
|
|
|
|
rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
|
|
|
|
(struct smb_hdr *)pSMBr, &bytes_returned,
|
|
|
|
CIFS_ASYNC_OP);
|
|
|
|
if (rc) {
|
|
|
|
cFYI(1, "Error in Notify = %d", rc);
|
|
|
|
} else {
|
|
|
|
/* Add file to outstanding requests */
|
|
|
|
/* BB change to kmem cache alloc */
|
|
|
|
dnotify_req = kmalloc(
|
|
|
|
sizeof(struct dir_notify_req),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (dnotify_req) {
|
|
|
|
dnotify_req->Pid = pSMB->hdr.Pid;
|
|
|
|
dnotify_req->PidHigh = pSMB->hdr.PidHigh;
|
|
|
|
dnotify_req->Mid = pSMB->hdr.Mid;
|
|
|
|
dnotify_req->Tid = pSMB->hdr.Tid;
|
|
|
|
dnotify_req->Uid = pSMB->hdr.Uid;
|
|
|
|
dnotify_req->netfid = netfid;
|
|
|
|
dnotify_req->pfile = pfile;
|
|
|
|
dnotify_req->filter = filter;
|
|
|
|
dnotify_req->multishot = multishot;
|
|
|
|
spin_lock(&GlobalMid_Lock);
|
|
|
|
list_add_tail(&dnotify_req->lhead,
|
|
|
|
&GlobalDnotifyReqList);
|
|
|
|
spin_unlock(&GlobalMid_Lock);
|
|
|
|
} else
|
|
|
|
rc = -ENOMEM;
|
|
|
|
}
|
|
|
|
cifs_buf_release(pSMB);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
|