blob: 4435b11c41b93358b7727bb8492c5c4411e07ea7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/cifssmb.c
3 *
Steve Frenchf19159d2010-04-21 04:12:10 +00004 * Copyright (C) International Business Machines Corp., 2002,2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Contains the routines for constructing the SMB PDUs themselves
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */
25 /* These are mostly routines that operate on a pathname, or on a tree id */
26 /* (mounted volume), but there are eight handle based routines which must be */
Steve French2dd29d32007-04-23 22:07:35 +000027 /* treated slightly differently for reconnection purposes since we never */
28 /* want to reuse a stale file handle and only the caller knows the file info */
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include <linux/fs.h>
31#include <linux/kernel.h>
32#include <linux/vfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/posix_acl_xattr.h>
Jeff Laytonc28c89f2011-05-19 16:22:56 -040035#include <linux/pagemap.h>
Jeff Laytone28bc5b2011-10-19 15:30:07 -040036#include <linux/swap.h>
37#include <linux/task_io_accounting_ops.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/uaccess.h>
39#include "cifspdu.h"
40#include "cifsglob.h"
Shirish Pargaonkard0d66c42007-10-03 18:22:19 +000041#include "cifsacl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "cifsproto.h"
43#include "cifs_unicode.h"
44#include "cifs_debug.h"
Jeff Laytone28bc5b2011-10-19 15:30:07 -040045#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#ifdef CONFIG_CIFS_POSIX
48static struct {
49 int index;
50 char *name;
51} protocols[] = {
Steve French39798772006-05-31 22:40:51 +000052#ifdef CONFIG_CIFS_WEAK_PW_HASH
53 {LANMAN_PROT, "\2LM1.2X002"},
Steve French9ac00b72006-09-30 04:13:17 +000054 {LANMAN2_PROT, "\2LANMAN2.1"},
Steve French39798772006-05-31 22:40:51 +000055#endif /* weak password hashing for legacy clients */
Steve French50c2f752007-07-13 00:33:32 +000056 {CIFS_PROT, "\2NT LM 0.12"},
Steve French39798772006-05-31 22:40:51 +000057 {POSIX_PROT, "\2POSIX 2"},
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 {BAD_PROT, "\2"}
59};
60#else
61static struct {
62 int index;
63 char *name;
64} protocols[] = {
Steve French39798772006-05-31 22:40:51 +000065#ifdef CONFIG_CIFS_WEAK_PW_HASH
66 {LANMAN_PROT, "\2LM1.2X002"},
Steve French18f75ca2006-10-01 03:13:01 +000067 {LANMAN2_PROT, "\2LANMAN2.1"},
Steve French39798772006-05-31 22:40:51 +000068#endif /* weak password hashing for legacy clients */
Steve French790fe572007-07-07 19:25:05 +000069 {CIFS_PROT, "\2NT LM 0.12"},
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 {BAD_PROT, "\2"}
71};
72#endif
73
Steve French39798772006-05-31 22:40:51 +000074/* define the number of elements in the cifs dialect array */
75#ifdef CONFIG_CIFS_POSIX
76#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French9ac00b72006-09-30 04:13:17 +000077#define CIFS_NUM_PROT 4
Steve French39798772006-05-31 22:40:51 +000078#else
79#define CIFS_NUM_PROT 2
80#endif /* CIFS_WEAK_PW_HASH */
81#else /* not posix */
82#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French9ac00b72006-09-30 04:13:17 +000083#define CIFS_NUM_PROT 3
Steve French39798772006-05-31 22:40:51 +000084#else
85#define CIFS_NUM_PROT 1
86#endif /* CONFIG_CIFS_WEAK_PW_HASH */
87#endif /* CIFS_POSIX */
88
Jeff Laytone28bc5b2011-10-19 15:30:07 -040089/* Forward declarations */
90static void cifs_readv_complete(struct work_struct *work);
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092/* Mark as invalid, all open files on tree connections since they
93 were closed when session to server was lost */
Steve French96daf2b2011-05-27 04:34:02 +000094static void mark_open_files_invalid(struct cifs_tcon *pTcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
96 struct cifsFileInfo *open_file = NULL;
Steve French790fe572007-07-07 19:25:05 +000097 struct list_head *tmp;
98 struct list_head *tmp1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100/* list all files open on tree connection and mark them invalid */
Jeff Layton44772882010-10-15 15:34:03 -0400101 spin_lock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
Steve French790fe572007-07-07 19:25:05 +0000103 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
Steve Frenchad8b15f2008-08-08 21:10:16 +0000104 open_file->invalidHandle = true;
Jeff Layton3bc303c2009-09-21 06:47:50 -0400105 open_file->oplock_break_cancelled = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 }
Jeff Layton44772882010-10-15 15:34:03 -0400107 spin_unlock(&cifs_file_list_lock);
Steve French09d1db52005-04-28 22:41:08 -0700108 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
109 to this tcon */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
Jeff Layton9162ab22009-09-03 12:07:17 -0400112/* reconnect the socket, tcon, and smb session if needed */
113static int
Steve French96daf2b2011-05-27 04:34:02 +0000114cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
Jeff Layton9162ab22009-09-03 12:07:17 -0400115{
Jeff Laytonc4a55342011-07-28 12:40:36 -0400116 int rc;
Steve French96daf2b2011-05-27 04:34:02 +0000117 struct cifs_ses *ses;
Jeff Layton9162ab22009-09-03 12:07:17 -0400118 struct TCP_Server_Info *server;
119 struct nls_table *nls_codepage;
120
121 /*
122 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
123 * tcp and smb session status done differently for those three - in the
124 * calling routine
125 */
126 if (!tcon)
127 return 0;
128
129 ses = tcon->ses;
130 server = ses->server;
131
132 /*
133 * only tree disconnect, open, and write, (and ulogoff which does not
134 * have tcon) are allowed as we start force umount
135 */
136 if (tcon->tidStatus == CifsExiting) {
137 if (smb_command != SMB_COM_WRITE_ANDX &&
138 smb_command != SMB_COM_OPEN_ANDX &&
139 smb_command != SMB_COM_TREE_DISCONNECT) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000140 cFYI(1, "can not send cmd %d while umounting",
141 smb_command);
Jeff Layton9162ab22009-09-03 12:07:17 -0400142 return -ENODEV;
143 }
144 }
145
Jeff Layton9162ab22009-09-03 12:07:17 -0400146 /*
147 * Give demultiplex thread up to 10 seconds to reconnect, should be
148 * greater than cifs socket timeout which is 7 seconds
149 */
150 while (server->tcpStatus == CifsNeedReconnect) {
151 wait_event_interruptible_timeout(server->response_q,
Steve Frenchfd88ce92011-04-12 01:01:14 +0000152 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
Jeff Layton9162ab22009-09-03 12:07:17 -0400153
Steve Frenchfd88ce92011-04-12 01:01:14 +0000154 /* are we still trying to reconnect? */
Jeff Layton9162ab22009-09-03 12:07:17 -0400155 if (server->tcpStatus != CifsNeedReconnect)
156 break;
157
158 /*
159 * on "soft" mounts we wait once. Hard mounts keep
160 * retrying until process is killed or server comes
161 * back on-line
162 */
Jeff Laytond4025392011-02-07 08:54:35 -0500163 if (!tcon->retry) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000164 cFYI(1, "gave up waiting on reconnect in smb_init");
Jeff Layton9162ab22009-09-03 12:07:17 -0400165 return -EHOSTDOWN;
166 }
167 }
168
169 if (!ses->need_reconnect && !tcon->need_reconnect)
170 return 0;
171
172 nls_codepage = load_nls_default();
173
174 /*
175 * need to prevent multiple threads trying to simultaneously
176 * reconnect the same SMB session
177 */
Steve Frenchd7b619c2010-02-25 05:36:46 +0000178 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -0400179 rc = cifs_negotiate_protocol(0, ses);
180 if (rc == 0 && ses->need_reconnect)
Jeff Layton9162ab22009-09-03 12:07:17 -0400181 rc = cifs_setup_session(0, ses, nls_codepage);
182
183 /* do we need to reconnect tcon? */
184 if (rc || !tcon->need_reconnect) {
Steve Frenchd7b619c2010-02-25 05:36:46 +0000185 mutex_unlock(&ses->session_mutex);
Jeff Layton9162ab22009-09-03 12:07:17 -0400186 goto out;
187 }
188
189 mark_open_files_invalid(tcon);
190 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
Steve Frenchd7b619c2010-02-25 05:36:46 +0000191 mutex_unlock(&ses->session_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000192 cFYI(1, "reconnect tcon rc = %d", rc);
Jeff Layton9162ab22009-09-03 12:07:17 -0400193
194 if (rc)
195 goto out;
196
197 /*
198 * FIXME: check if wsize needs updated due to negotiated smb buffer
199 * size shrinking
200 */
201 atomic_inc(&tconInfoReconnectCount);
202
203 /* tell server Unix caps we support */
204 if (ses->capabilities & CAP_UNIX)
205 reset_cifs_unix_caps(0, tcon, NULL, NULL);
206
207 /*
208 * Removed call to reopen open files here. It is safer (and faster) to
209 * reopen files one at a time as needed in read and write.
210 *
211 * FIXME: what about file locks? don't we need to reclaim them ASAP?
212 */
213
214out:
215 /*
216 * Check if handle based operation so we know whether we can continue
217 * or not without returning to caller to reset file handle
218 */
219 switch (smb_command) {
220 case SMB_COM_READ_ANDX:
221 case SMB_COM_WRITE_ANDX:
222 case SMB_COM_CLOSE:
223 case SMB_COM_FIND_CLOSE2:
224 case SMB_COM_LOCKING_ANDX:
225 rc = -EAGAIN;
226 }
227
228 unload_nls(nls_codepage);
229 return rc;
230}
231
Steve Frenchad7a2922008-02-07 23:25:02 +0000232/* Allocate and return pointer to an SMB request buffer, and set basic
233 SMB information in the SMB header. If the return code is zero, this
234 function must have filled in request_buf pointer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235static int
Steve French96daf2b2011-05-27 04:34:02 +0000236small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +0000237 void **request_buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
Jeff Laytonf5695992010-09-29 15:27:08 -0400239 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Jeff Layton9162ab22009-09-03 12:07:17 -0400241 rc = cifs_reconnect_tcon(tcon, smb_command);
Steve French790fe572007-07-07 19:25:05 +0000242 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 return rc;
244
245 *request_buf = cifs_small_buf_get();
246 if (*request_buf == NULL) {
247 /* BB should we add a retry in here if not a writepage? */
248 return -ENOMEM;
249 }
250
Steve French63135e02007-07-17 17:34:02 +0000251 header_assemble((struct smb_hdr *) *request_buf, smb_command,
Steve Frenchc18c8422007-07-18 23:21:09 +0000252 tcon, wct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
Steve French790fe572007-07-07 19:25:05 +0000254 if (tcon != NULL)
255 cifs_stats_inc(&tcon->num_smbs_sent);
Steve Frencha4544342005-08-24 13:59:35 -0700256
Jeff Laytonf5695992010-09-29 15:27:08 -0400257 return 0;
Steve French5815449d2006-02-14 01:36:20 +0000258}
259
Steve French12b3b8f2006-02-09 21:12:47 +0000260int
Steve French50c2f752007-07-13 00:33:32 +0000261small_smb_init_no_tc(const int smb_command, const int wct,
Steve French96daf2b2011-05-27 04:34:02 +0000262 struct cifs_ses *ses, void **request_buf)
Steve French12b3b8f2006-02-09 21:12:47 +0000263{
264 int rc;
Steve French50c2f752007-07-13 00:33:32 +0000265 struct smb_hdr *buffer;
Steve French12b3b8f2006-02-09 21:12:47 +0000266
Steve French5815449d2006-02-14 01:36:20 +0000267 rc = small_smb_init(smb_command, wct, NULL, request_buf);
Steve French790fe572007-07-07 19:25:05 +0000268 if (rc)
Steve French12b3b8f2006-02-09 21:12:47 +0000269 return rc;
270
Steve French04fdabe2006-02-10 05:52:50 +0000271 buffer = (struct smb_hdr *)*request_buf;
Steve French12b3b8f2006-02-09 21:12:47 +0000272 buffer->Mid = GetNextMid(ses->server);
273 if (ses->capabilities & CAP_UNICODE)
274 buffer->Flags2 |= SMBFLG2_UNICODE;
Steve French04fdabe2006-02-10 05:52:50 +0000275 if (ses->capabilities & CAP_STATUS32)
Steve French12b3b8f2006-02-09 21:12:47 +0000276 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
277
278 /* uid, tid can stay at zero as set in header assemble */
279
Steve French50c2f752007-07-13 00:33:32 +0000280 /* BB add support for turning on the signing when
Steve French12b3b8f2006-02-09 21:12:47 +0000281 this function is used after 1st of session setup requests */
282
283 return rc;
284}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286/* If the return code is zero, this function must fill in request_buf pointer */
287static int
Steve French96daf2b2011-05-27 04:34:02 +0000288__smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400289 void **request_buf, void **response_buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 *request_buf = cifs_buf_get();
292 if (*request_buf == NULL) {
293 /* BB should we add a retry in here if not a writepage? */
294 return -ENOMEM;
295 }
296 /* Although the original thought was we needed the response buf for */
297 /* potential retries of smb operations it turns out we can determine */
298 /* from the mid flags when the request buffer can be resent without */
299 /* having to use a second distinct buffer for the response */
Steve French790fe572007-07-07 19:25:05 +0000300 if (response_buf)
Steve French50c2f752007-07-13 00:33:32 +0000301 *response_buf = *request_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +0000304 wct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Steve French790fe572007-07-07 19:25:05 +0000306 if (tcon != NULL)
307 cifs_stats_inc(&tcon->num_smbs_sent);
Steve Frencha4544342005-08-24 13:59:35 -0700308
Jeff Laytonf5695992010-09-29 15:27:08 -0400309 return 0;
310}
311
312/* If the return code is zero, this function must fill in request_buf pointer */
313static int
Steve French96daf2b2011-05-27 04:34:02 +0000314smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400315 void **request_buf, void **response_buf)
316{
317 int rc;
318
319 rc = cifs_reconnect_tcon(tcon, smb_command);
320 if (rc)
321 return rc;
322
323 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
324}
325
326static int
Steve French96daf2b2011-05-27 04:34:02 +0000327smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400328 void **request_buf, void **response_buf)
329{
330 if (tcon->ses->need_reconnect || tcon->need_reconnect)
331 return -EHOSTDOWN;
332
333 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
335
Steve French50c2f752007-07-13 00:33:32 +0000336static int validate_t2(struct smb_t2_rsp *pSMB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Jeff Layton12df83c2011-01-20 13:36:51 -0500338 unsigned int total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
Jeff Layton12df83c2011-01-20 13:36:51 -0500340 /* check for plausible wct */
341 if (pSMB->hdr.WordCount < 10)
342 goto vt2_err;
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 /* check for parm and data offset going beyond end of smb */
Jeff Layton12df83c2011-01-20 13:36:51 -0500345 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
346 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
347 goto vt2_err;
348
Jeff Layton12df83c2011-01-20 13:36:51 -0500349 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
350 if (total_size >= 512)
351 goto vt2_err;
352
Jeff Laytonfd5707e2011-03-31 17:22:07 -0400353 /* check that bcc is at least as big as parms + data, and that it is
354 * less than negotiated smb buffer
355 */
Jeff Layton12df83c2011-01-20 13:36:51 -0500356 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
357 if (total_size > get_bcc(&pSMB->hdr) ||
358 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
359 goto vt2_err;
360
361 return 0;
362vt2_err:
Steve French50c2f752007-07-13 00:33:32 +0000363 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 sizeof(struct smb_t2_rsp) + 16);
Jeff Layton12df83c2011-01-20 13:36:51 -0500365 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
Jeff Layton690c5222011-01-20 13:36:51 -0500367
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000368static inline void inc_rfc1001_len(void *pSMB, int count)
369{
370 struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
371
372 be32_add_cpu(&hdr->smb_buf_length, count);
373}
374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375int
Steve French96daf2b2011-05-27 04:34:02 +0000376CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377{
378 NEGOTIATE_REQ *pSMB;
379 NEGOTIATE_RSP *pSMBr;
380 int rc = 0;
381 int bytes_returned;
Steve French39798772006-05-31 22:40:51 +0000382 int i;
Steve French50c2f752007-07-13 00:33:32 +0000383 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 u16 count;
Steve French750d1152006-06-27 06:28:30 +0000385 unsigned int secFlags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Steve French790fe572007-07-07 19:25:05 +0000387 if (ses->server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 server = ses->server;
389 else {
390 rc = -EIO;
391 return rc;
392 }
393 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
394 (void **) &pSMB, (void **) &pSMBr);
395 if (rc)
396 return rc;
Steve French750d1152006-06-27 06:28:30 +0000397
398 /* if any of auth flags (ie not sign or seal) are overriden use them */
Steve French790fe572007-07-07 19:25:05 +0000399 if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
Steve French762e5ab2007-06-28 18:41:42 +0000400 secFlags = ses->overrideSecFlg; /* BB FIXME fix sign flags? */
Steve French750d1152006-06-27 06:28:30 +0000401 else /* if override flags set only sign/seal OR them with global auth */
Jeff Layton04912d62010-04-24 07:57:45 -0400402 secFlags = global_secflags | ses->overrideSecFlg;
Steve French750d1152006-06-27 06:28:30 +0000403
Joe Perchesb6b38f72010-04-21 03:50:45 +0000404 cFYI(1, "secFlags 0x%x", secFlags);
Steve Frenchf40c5622006-06-28 00:13:38 +0000405
Steve French1982c342005-08-17 12:38:22 -0700406 pSMB->hdr.Mid = GetNextMid(server);
Yehuda Sadeh Weinraub100c1dd2007-06-05 21:31:16 +0000407 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
Steve Frencha0136892007-10-04 20:05:09 +0000408
Yehuda Sadeh Weinraub100c1dd2007-06-05 21:31:16 +0000409 if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
Steve French254e55e2006-06-04 05:53:15 +0000410 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
Steve Frencha0136892007-10-04 20:05:09 +0000411 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000412 cFYI(1, "Kerberos only mechanism, enable extended security");
Steve Frencha0136892007-10-04 20:05:09 +0000413 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
Jeff Laytonb4d6fcf2011-01-07 11:30:28 -0500414 } else if ((secFlags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
Steve Frenchac683922009-05-06 04:16:04 +0000415 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
416 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_NTLMSSP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000417 cFYI(1, "NTLMSSP only mechanism, enable extended security");
Steve Frenchac683922009-05-06 04:16:04 +0000418 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
419 }
Steve French50c2f752007-07-13 00:33:32 +0000420
Steve French39798772006-05-31 22:40:51 +0000421 count = 0;
Steve French50c2f752007-07-13 00:33:32 +0000422 for (i = 0; i < CIFS_NUM_PROT; i++) {
Steve French39798772006-05-31 22:40:51 +0000423 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
424 count += strlen(protocols[i].name) + 1;
425 /* null at end of source and target buffers anyway */
426 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000427 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 pSMB->ByteCount = cpu_to_le16(count);
429
430 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
431 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French50c2f752007-07-13 00:33:32 +0000432 if (rc != 0)
Steve French254e55e2006-06-04 05:53:15 +0000433 goto neg_err_exit;
434
Jeff Layton9bf67e52010-04-24 07:57:46 -0400435 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
436 cFYI(1, "Dialect: %d", server->dialect);
Steve French254e55e2006-06-04 05:53:15 +0000437 /* Check wct = 1 error case */
Jeff Layton9bf67e52010-04-24 07:57:46 -0400438 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
Steve French254e55e2006-06-04 05:53:15 +0000439 /* core returns wct = 1, but we do not ask for core - otherwise
Steve French50c2f752007-07-13 00:33:32 +0000440 small wct just comes when dialect index is -1 indicating we
Steve French254e55e2006-06-04 05:53:15 +0000441 could not negotiate a common dialect */
442 rc = -EOPNOTSUPP;
443 goto neg_err_exit;
Steve French50c2f752007-07-13 00:33:32 +0000444#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French790fe572007-07-07 19:25:05 +0000445 } else if ((pSMBr->hdr.WordCount == 13)
Jeff Layton9bf67e52010-04-24 07:57:46 -0400446 && ((server->dialect == LANMAN_PROT)
447 || (server->dialect == LANMAN2_PROT))) {
Steve Frenchb815f1e2006-10-02 05:53:29 +0000448 __s16 tmp;
Steve French50c2f752007-07-13 00:33:32 +0000449 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
Steve French254e55e2006-06-04 05:53:15 +0000450
Steve French790fe572007-07-07 19:25:05 +0000451 if ((secFlags & CIFSSEC_MAY_LANMAN) ||
Steve French750d1152006-06-27 06:28:30 +0000452 (secFlags & CIFSSEC_MAY_PLNTXT))
Steve French254e55e2006-06-04 05:53:15 +0000453 server->secType = LANMAN;
454 else {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000455 cERROR(1, "mount failed weak security disabled"
456 " in /proc/fs/cifs/SecurityFlags");
Steve French39798772006-05-31 22:40:51 +0000457 rc = -EOPNOTSUPP;
458 goto neg_err_exit;
Steve French50c2f752007-07-13 00:33:32 +0000459 }
Steve French96daf2b2011-05-27 04:34:02 +0000460 server->sec_mode = (__u8)le16_to_cpu(rsp->SecurityMode);
Steve French254e55e2006-06-04 05:53:15 +0000461 server->maxReq = le16_to_cpu(rsp->MaxMpxCount);
Jeff Laytonc974bef2011-10-11 06:41:32 -0400462 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
Steve Frencheca6acf2009-02-20 05:43:09 +0000463 server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
Steve French254e55e2006-06-04 05:53:15 +0000464 /* even though we do not use raw we might as well set this
465 accurately, in case we ever find a need for it */
Steve French790fe572007-07-07 19:25:05 +0000466 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
Steve Frencheca6acf2009-02-20 05:43:09 +0000467 server->max_rw = 0xFF00;
Steve French254e55e2006-06-04 05:53:15 +0000468 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
469 } else {
Steve Frencheca6acf2009-02-20 05:43:09 +0000470 server->max_rw = 0;/* do not need to use raw anyway */
Steve French254e55e2006-06-04 05:53:15 +0000471 server->capabilities = CAP_MPX_MODE;
472 }
Steve Frenchb815f1e2006-10-02 05:53:29 +0000473 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
Steve French1a70d652006-10-02 05:59:18 +0000474 if (tmp == -1) {
Steve French25ee4a92006-09-30 00:54:23 +0000475 /* OS/2 often does not set timezone therefore
476 * we must use server time to calc time zone.
Steve Frenchb815f1e2006-10-02 05:53:29 +0000477 * Could deviate slightly from the right zone.
478 * Smallest defined timezone difference is 15 minutes
479 * (i.e. Nepal). Rounding up/down is done to match
480 * this requirement.
Steve French25ee4a92006-09-30 00:54:23 +0000481 */
Steve Frenchb815f1e2006-10-02 05:53:29 +0000482 int val, seconds, remain, result;
Steve French25ee4a92006-09-30 00:54:23 +0000483 struct timespec ts, utc;
484 utc = CURRENT_TIME;
Jeff Laytonc4a2c082009-05-27 09:37:33 -0400485 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
486 rsp->SrvTime.Time, 0);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000487 cFYI(1, "SrvTime %d sec since 1970 (utc: %d) diff: %d",
Steve French50c2f752007-07-13 00:33:32 +0000488 (int)ts.tv_sec, (int)utc.tv_sec,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000489 (int)(utc.tv_sec - ts.tv_sec));
Steve Frenchb815f1e2006-10-02 05:53:29 +0000490 val = (int)(utc.tv_sec - ts.tv_sec);
Andre Haupt8594c152007-08-30 20:18:41 +0000491 seconds = abs(val);
Steve French947a5062006-10-02 05:55:25 +0000492 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
Steve Frenchb815f1e2006-10-02 05:53:29 +0000493 remain = seconds % MIN_TZ_ADJ;
Steve French790fe572007-07-07 19:25:05 +0000494 if (remain >= (MIN_TZ_ADJ / 2))
Steve Frenchb815f1e2006-10-02 05:53:29 +0000495 result += MIN_TZ_ADJ;
Steve French790fe572007-07-07 19:25:05 +0000496 if (val < 0)
Steve Frenchad7a2922008-02-07 23:25:02 +0000497 result = -result;
Steve Frenchb815f1e2006-10-02 05:53:29 +0000498 server->timeAdj = result;
Steve French25ee4a92006-09-30 00:54:23 +0000499 } else {
Steve Frenchb815f1e2006-10-02 05:53:29 +0000500 server->timeAdj = (int)tmp;
501 server->timeAdj *= 60; /* also in seconds */
Steve French25ee4a92006-09-30 00:54:23 +0000502 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000503 cFYI(1, "server->timeAdj: %d seconds", server->timeAdj);
Steve French25ee4a92006-09-30 00:54:23 +0000504
Steve French39798772006-05-31 22:40:51 +0000505
Steve French254e55e2006-06-04 05:53:15 +0000506 /* BB get server time for time conversions and add
Steve French50c2f752007-07-13 00:33:32 +0000507 code to use it and timezone since this is not UTC */
Steve French39798772006-05-31 22:40:51 +0000508
Steve French50c2f752007-07-13 00:33:32 +0000509 if (rsp->EncryptionKeyLength ==
Steve French25ee4a92006-09-30 00:54:23 +0000510 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500511 memcpy(ses->server->cryptkey, rsp->EncryptionKey,
Steve French254e55e2006-06-04 05:53:15 +0000512 CIFS_CRYPTO_KEY_SIZE);
Steve French96daf2b2011-05-27 04:34:02 +0000513 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
Steve French254e55e2006-06-04 05:53:15 +0000514 rc = -EIO; /* need cryptkey unless plain text */
515 goto neg_err_exit;
516 }
Steve French39798772006-05-31 22:40:51 +0000517
Steve Frenchf19159d2010-04-21 04:12:10 +0000518 cFYI(1, "LANMAN negotiated");
Steve French254e55e2006-06-04 05:53:15 +0000519 /* we will not end up setting signing flags - as no signing
520 was in LANMAN and server did not return the flags on */
521 goto signing_check;
Steve French7c7b25b2006-06-01 19:20:10 +0000522#else /* weak security disabled */
Steve French790fe572007-07-07 19:25:05 +0000523 } else if (pSMBr->hdr.WordCount == 13) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000524 cERROR(1, "mount failed, cifs module not built "
525 "with CIFS_WEAK_PW_HASH support");
Dan Carpenter8212cf72010-03-15 11:22:26 +0300526 rc = -EOPNOTSUPP;
Steve French7c7b25b2006-06-01 19:20:10 +0000527#endif /* WEAK_PW_HASH */
Steve French254e55e2006-06-04 05:53:15 +0000528 goto neg_err_exit;
Steve French790fe572007-07-07 19:25:05 +0000529 } else if (pSMBr->hdr.WordCount != 17) {
Steve French254e55e2006-06-04 05:53:15 +0000530 /* unknown wct */
531 rc = -EOPNOTSUPP;
532 goto neg_err_exit;
533 }
534 /* else wct == 17 NTLM */
Steve French96daf2b2011-05-27 04:34:02 +0000535 server->sec_mode = pSMBr->SecurityMode;
536 if ((server->sec_mode & SECMODE_USER) == 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000537 cFYI(1, "share mode security");
Steve French39798772006-05-31 22:40:51 +0000538
Steve French96daf2b2011-05-27 04:34:02 +0000539 if ((server->sec_mode & SECMODE_PW_ENCRYPT) == 0)
Steve Frenchbdc4bf6e2006-06-02 22:57:13 +0000540#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French750d1152006-06-27 06:28:30 +0000541 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
Steve Frenchbdc4bf6e2006-06-02 22:57:13 +0000542#endif /* CIFS_WEAK_PW_HASH */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000543 cERROR(1, "Server requests plain text password"
544 " but client support disabled");
Steve French9312f672006-06-04 22:21:07 +0000545
Steve French790fe572007-07-07 19:25:05 +0000546 if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
Steve French254e55e2006-06-04 05:53:15 +0000547 server->secType = NTLMv2;
Steve French790fe572007-07-07 19:25:05 +0000548 else if (secFlags & CIFSSEC_MAY_NTLM)
Steve French254e55e2006-06-04 05:53:15 +0000549 server->secType = NTLM;
Steve French790fe572007-07-07 19:25:05 +0000550 else if (secFlags & CIFSSEC_MAY_NTLMV2)
Steve Frenchf40c5622006-06-28 00:13:38 +0000551 server->secType = NTLMv2;
Steve Frencha0136892007-10-04 20:05:09 +0000552 else if (secFlags & CIFSSEC_MAY_KRB5)
553 server->secType = Kerberos;
Steve Frenchac683922009-05-06 04:16:04 +0000554 else if (secFlags & CIFSSEC_MAY_NTLMSSP)
Steve Frenchf46c7232009-06-25 03:04:20 +0000555 server->secType = RawNTLMSSP;
Steve Frencha0136892007-10-04 20:05:09 +0000556 else if (secFlags & CIFSSEC_MAY_LANMAN)
557 server->secType = LANMAN;
Steve Frencha0136892007-10-04 20:05:09 +0000558 else {
559 rc = -EOPNOTSUPP;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000560 cERROR(1, "Invalid security type");
Steve Frencha0136892007-10-04 20:05:09 +0000561 goto neg_err_exit;
562 }
563 /* else ... any others ...? */
Steve French7c7b25b2006-06-01 19:20:10 +0000564
Steve French254e55e2006-06-04 05:53:15 +0000565 /* one byte, so no need to convert this or EncryptionKeyLen from
566 little endian */
567 server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
568 /* probably no need to store and check maxvcs */
Jeff Laytonc974bef2011-10-11 06:41:32 -0400569 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
Steve Frencheca6acf2009-02-20 05:43:09 +0000570 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000571 cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
Steve French254e55e2006-06-04 05:53:15 +0000572 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
Steve Frenchb815f1e2006-10-02 05:53:29 +0000573 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
574 server->timeAdj *= 60;
Steve French254e55e2006-06-04 05:53:15 +0000575 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500576 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
Steve French254e55e2006-06-04 05:53:15 +0000577 CIFS_CRYPTO_KEY_SIZE);
Steve French07cc6cf2011-05-27 04:12:29 +0000578 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
579 server->capabilities & CAP_EXTENDED_SECURITY) &&
580 (pSMBr->EncryptionKeyLength == 0)) {
Steve French254e55e2006-06-04 05:53:15 +0000581 /* decode security blob */
Jeff Layton820a8032011-05-04 08:05:26 -0400582 count = get_bcc(&pSMBr->hdr);
Jeff Laytone187e442007-10-16 17:10:44 +0000583 if (count < 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 rc = -EIO;
Jeff Laytone187e442007-10-16 17:10:44 +0000585 goto neg_err_exit;
586 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530587 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500588 if (server->srv_count > 1) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530589 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone187e442007-10-16 17:10:44 +0000590 if (memcmp(server->server_GUID,
591 pSMBr->u.extended_response.
592 GUID, 16) != 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000593 cFYI(1, "server UID changed");
Steve French254e55e2006-06-04 05:53:15 +0000594 memcpy(server->server_GUID,
Jeff Laytone187e442007-10-16 17:10:44 +0000595 pSMBr->u.extended_response.GUID,
596 16);
597 }
Jeff Laytone7ddee92008-11-14 13:44:38 -0500598 } else {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530599 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone187e442007-10-16 17:10:44 +0000600 memcpy(server->server_GUID,
601 pSMBr->u.extended_response.GUID, 16);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500602 }
Jeff Laytone187e442007-10-16 17:10:44 +0000603
604 if (count == 16) {
605 server->secType = RawNTLMSSP;
Steve French254e55e2006-06-04 05:53:15 +0000606 } else {
607 rc = decode_negTokenInit(pSMBr->u.extended_response.
Jeff Layton26efa0b2010-04-24 07:57:49 -0400608 SecurityBlob, count - 16,
609 server);
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +0000610 if (rc == 1)
Jeff Laytone5459372007-11-03 05:11:06 +0000611 rc = 0;
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +0000612 else
Steve French254e55e2006-06-04 05:53:15 +0000613 rc = -EINVAL;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500614 if (server->secType == Kerberos) {
615 if (!server->sec_kerberos &&
616 !server->sec_mskerberos)
617 rc = -EOPNOTSUPP;
618 } else if (server->secType == RawNTLMSSP) {
619 if (!server->sec_ntlmssp)
620 rc = -EOPNOTSUPP;
621 } else
622 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
Steve French96daf2b2011-05-27 04:34:02 +0000624 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
Steve French07cc6cf2011-05-27 04:12:29 +0000625 rc = -EIO; /* no crypt key only if plain text pwd */
626 goto neg_err_exit;
Steve French254e55e2006-06-04 05:53:15 +0000627 } else
628 server->capabilities &= ~CAP_EXTENDED_SECURITY;
629
Steve French6344a422006-06-12 04:18:35 +0000630#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French254e55e2006-06-04 05:53:15 +0000631signing_check:
Steve French6344a422006-06-12 04:18:35 +0000632#endif
Steve French762e5ab2007-06-28 18:41:42 +0000633 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
634 /* MUST_SIGN already includes the MAY_SIGN FLAG
635 so if this is zero it means that signing is disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000636 cFYI(1, "Signing disabled");
Steve French96daf2b2011-05-27 04:34:02 +0000637 if (server->sec_mode & SECMODE_SIGN_REQUIRED) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000638 cERROR(1, "Server requires "
Jeff Layton7111d212007-10-16 16:50:25 +0000639 "packet signing to be enabled in "
Joe Perchesb6b38f72010-04-21 03:50:45 +0000640 "/proc/fs/cifs/SecurityFlags.");
Steve Frenchabb63d62007-10-18 02:58:40 +0000641 rc = -EOPNOTSUPP;
642 }
Steve French96daf2b2011-05-27 04:34:02 +0000643 server->sec_mode &=
Steve French254e55e2006-06-04 05:53:15 +0000644 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
Steve French762e5ab2007-06-28 18:41:42 +0000645 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
646 /* signing required */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000647 cFYI(1, "Must sign - secFlags 0x%x", secFlags);
Steve French96daf2b2011-05-27 04:34:02 +0000648 if ((server->sec_mode &
Steve French762e5ab2007-06-28 18:41:42 +0000649 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000650 cERROR(1, "signing required but server lacks support");
Jeff38c10a12007-07-06 21:10:07 +0000651 rc = -EOPNOTSUPP;
Steve French762e5ab2007-06-28 18:41:42 +0000652 } else
Steve French96daf2b2011-05-27 04:34:02 +0000653 server->sec_mode |= SECMODE_SIGN_REQUIRED;
Steve French762e5ab2007-06-28 18:41:42 +0000654 } else {
655 /* signing optional ie CIFSSEC_MAY_SIGN */
Steve French96daf2b2011-05-27 04:34:02 +0000656 if ((server->sec_mode & SECMODE_SIGN_REQUIRED) == 0)
657 server->sec_mode &=
Steve French254e55e2006-06-04 05:53:15 +0000658 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 }
Steve French50c2f752007-07-13 00:33:32 +0000660
661neg_err_exit:
Steve French4a6d87f2005-08-13 08:15:54 -0700662 cifs_buf_release(pSMB);
Steve French254e55e2006-06-04 05:53:15 +0000663
Joe Perchesb6b38f72010-04-21 03:50:45 +0000664 cFYI(1, "negprot rc %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 return rc;
666}
667
668int
Steve French96daf2b2011-05-27 04:34:02 +0000669CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 struct smb_hdr *smb_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Joe Perchesb6b38f72010-04-21 03:50:45 +0000674 cFYI(1, "In tree disconnect");
Jeff Laytonf1987b42008-11-15 11:12:47 -0500675
676 /* BB: do we need to check this? These should never be NULL. */
677 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
678 return -EIO;
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 /*
Jeff Laytonf1987b42008-11-15 11:12:47 -0500681 * No need to return error on this operation if tid invalidated and
682 * closed on server already e.g. due to tcp session crashing. Also,
683 * the tcon is no longer on the list, so no need to take lock before
684 * checking this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 */
Steve French268875b2009-06-25 00:29:21 +0000686 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
Steve French50c2f752007-07-13 00:33:32 +0000687 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Steve French50c2f752007-07-13 00:33:32 +0000689 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
Steve French09d1db52005-04-28 22:41:08 -0700690 (void **)&smb_buffer);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500691 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return rc;
Steve French133672e2007-11-13 22:41:37 +0000693
694 rc = SendReceiveNoRsp(xid, tcon->ses, smb_buffer, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000696 cFYI(1, "Tree disconnect failed %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Steve French50c2f752007-07-13 00:33:32 +0000698 /* No need to return error on this operation if tid invalidated and
Jeff Laytonf1987b42008-11-15 11:12:47 -0500699 closed on server already e.g. due to tcp session crashing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (rc == -EAGAIN)
701 rc = 0;
702
703 return rc;
704}
705
Jeff Layton766fdbb2011-01-11 07:24:21 -0500706/*
707 * This is a no-op for now. We're not really interested in the reply, but
708 * rather in the fact that the server sent one and that server->lstrp
709 * gets updated.
710 *
711 * FIXME: maybe we should consider checking that the reply matches request?
712 */
713static void
714cifs_echo_callback(struct mid_q_entry *mid)
715{
716 struct TCP_Server_Info *server = mid->callback_data;
717
718 DeleteMidQEntry(mid);
719 atomic_dec(&server->inFlight);
720 wake_up(&server->request_q);
721}
722
723int
724CIFSSMBEcho(struct TCP_Server_Info *server)
725{
726 ECHO_REQ *smb;
727 int rc = 0;
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400728 struct kvec iov;
Jeff Layton766fdbb2011-01-11 07:24:21 -0500729
730 cFYI(1, "In echo request");
731
732 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
733 if (rc)
734 return rc;
735
736 /* set up echo request */
Steve French5443d132011-03-13 05:08:25 +0000737 smb->hdr.Tid = 0xffff;
Jeff Layton99d86c82011-01-20 21:19:25 -0500738 smb->hdr.WordCount = 1;
739 put_unaligned_le16(1, &smb->EchoCount);
Jeff Layton820a8032011-05-04 08:05:26 -0400740 put_bcc(1, &smb->hdr);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500741 smb->Data[0] = 'a';
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000742 inc_rfc1001_len(smb, 3);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400743 iov.iov_base = smb;
744 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
Jeff Layton766fdbb2011-01-11 07:24:21 -0500745
Jeff Layton44d22d82011-10-19 15:29:49 -0400746 rc = cifs_call_async(server, &iov, 1, NULL, cifs_echo_callback,
747 server, true);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500748 if (rc)
749 cFYI(1, "Echo request failed: %d", rc);
750
751 cifs_small_buf_release(smb);
752
753 return rc;
754}
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756int
Steve French96daf2b2011-05-27 04:34:02 +0000757CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 LOGOFF_ANDX_REQ *pSMB;
760 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Joe Perchesb6b38f72010-04-21 03:50:45 +0000762 cFYI(1, "In SMBLogoff for session disconnect");
Jeff Layton14fbf502008-11-14 13:53:46 -0500763
764 /*
765 * BB: do we need to check validity of ses and server? They should
766 * always be valid since we have an active reference. If not, that
767 * should probably be a BUG()
768 */
769 if (!ses || !ses->server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 return -EIO;
771
Steve Frenchd7b619c2010-02-25 05:36:46 +0000772 mutex_lock(&ses->session_mutex);
Steve French3b795212008-11-13 19:45:32 +0000773 if (ses->need_reconnect)
774 goto session_already_dead; /* no need to send SMBlogoff if uid
775 already closed due to reconnect */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
777 if (rc) {
Steve Frenchd7b619c2010-02-25 05:36:46 +0000778 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 return rc;
780 }
781
Steve French3b795212008-11-13 19:45:32 +0000782 pSMB->hdr.Mid = GetNextMid(ses->server);
Steve French1982c342005-08-17 12:38:22 -0700783
Steve French96daf2b2011-05-27 04:34:02 +0000784 if (ses->server->sec_mode &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
786 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
788 pSMB->hdr.Uid = ses->Suid;
789
790 pSMB->AndXCommand = 0xFF;
Steve French133672e2007-11-13 22:41:37 +0000791 rc = SendReceiveNoRsp(xid, ses, (struct smb_hdr *) pSMB, 0);
Steve French3b795212008-11-13 19:45:32 +0000792session_already_dead:
Steve Frenchd7b619c2010-02-25 05:36:46 +0000793 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 /* if session dead then we do not need to do ulogoff,
Steve French50c2f752007-07-13 00:33:32 +0000796 since server closed smb session, no sense reporting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 error */
798 if (rc == -EAGAIN)
799 rc = 0;
800 return rc;
801}
802
803int
Steve French96daf2b2011-05-27 04:34:02 +0000804CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French2d785a52007-07-15 01:48:57 +0000805 __u16 type, const struct nls_table *nls_codepage, int remap)
806{
807 TRANSACTION2_SPI_REQ *pSMB = NULL;
808 TRANSACTION2_SPI_RSP *pSMBr = NULL;
809 struct unlink_psx_rq *pRqD;
810 int name_len;
811 int rc = 0;
812 int bytes_returned = 0;
813 __u16 params, param_offset, offset, byte_count;
814
Joe Perchesb6b38f72010-04-21 03:50:45 +0000815 cFYI(1, "In POSIX delete");
Steve French2d785a52007-07-15 01:48:57 +0000816PsxDelete:
817 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
818 (void **) &pSMBr);
819 if (rc)
820 return rc;
821
822 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
823 name_len =
824 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
825 PATH_MAX, nls_codepage, remap);
826 name_len++; /* trailing null */
827 name_len *= 2;
828 } else { /* BB add path length overrun check */
829 name_len = strnlen(fileName, PATH_MAX);
830 name_len++; /* trailing null */
831 strncpy(pSMB->FileName, fileName, name_len);
832 }
833
834 params = 6 + name_len;
835 pSMB->MaxParameterCount = cpu_to_le16(2);
836 pSMB->MaxDataCount = 0; /* BB double check this with jra */
837 pSMB->MaxSetupCount = 0;
838 pSMB->Reserved = 0;
839 pSMB->Flags = 0;
840 pSMB->Timeout = 0;
841 pSMB->Reserved2 = 0;
842 param_offset = offsetof(struct smb_com_transaction2_spi_req,
843 InformationLevel) - 4;
844 offset = param_offset + params;
845
846 /* Setup pointer to Request Data (inode type) */
847 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
848 pRqD->type = cpu_to_le16(type);
849 pSMB->ParameterOffset = cpu_to_le16(param_offset);
850 pSMB->DataOffset = cpu_to_le16(offset);
851 pSMB->SetupCount = 1;
852 pSMB->Reserved3 = 0;
853 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
854 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
855
856 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
857 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
858 pSMB->ParameterCount = cpu_to_le16(params);
859 pSMB->TotalParameterCount = pSMB->ParameterCount;
860 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
861 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000862 inc_rfc1001_len(pSMB, byte_count);
Steve French2d785a52007-07-15 01:48:57 +0000863 pSMB->ByteCount = cpu_to_le16(byte_count);
864 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
865 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +0000866 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000867 cFYI(1, "Posix delete returned %d", rc);
Steve French2d785a52007-07-15 01:48:57 +0000868 cifs_buf_release(pSMB);
869
870 cifs_stats_inc(&tcon->num_deletes);
871
872 if (rc == -EAGAIN)
873 goto PsxDelete;
874
875 return rc;
876}
877
878int
Steve French96daf2b2011-05-27 04:34:02 +0000879CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French737b7582005-04-28 22:41:06 -0700880 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
882 DELETE_FILE_REQ *pSMB = NULL;
883 DELETE_FILE_RSP *pSMBr = NULL;
884 int rc = 0;
885 int bytes_returned;
886 int name_len;
887
888DelFileRetry:
889 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
890 (void **) &pSMBr);
891 if (rc)
892 return rc;
893
894 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
895 name_len =
Steve French50c2f752007-07-13 00:33:32 +0000896 cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
Steve French737b7582005-04-28 22:41:06 -0700897 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 name_len++; /* trailing null */
899 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700900 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 name_len = strnlen(fileName, PATH_MAX);
902 name_len++; /* trailing null */
903 strncpy(pSMB->fileName, fileName, name_len);
904 }
905 pSMB->SearchAttributes =
906 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
907 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000908 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 pSMB->ByteCount = cpu_to_le16(name_len + 1);
910 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
911 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -0700912 cifs_stats_inc(&tcon->num_deletes);
Steve Frenchad7a2922008-02-07 23:25:02 +0000913 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000914 cFYI(1, "Error in RMFile = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916 cifs_buf_release(pSMB);
917 if (rc == -EAGAIN)
918 goto DelFileRetry;
919
920 return rc;
921}
922
923int
Steve French96daf2b2011-05-27 04:34:02 +0000924CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
Steve French737b7582005-04-28 22:41:06 -0700925 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
927 DELETE_DIRECTORY_REQ *pSMB = NULL;
928 DELETE_DIRECTORY_RSP *pSMBr = NULL;
929 int rc = 0;
930 int bytes_returned;
931 int name_len;
932
Joe Perchesb6b38f72010-04-21 03:50:45 +0000933 cFYI(1, "In CIFSSMBRmDir");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934RmDirRetry:
935 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
936 (void **) &pSMBr);
937 if (rc)
938 return rc;
939
940 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve French737b7582005-04-28 22:41:06 -0700941 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
942 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 name_len++; /* trailing null */
944 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700945 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 name_len = strnlen(dirName, PATH_MAX);
947 name_len++; /* trailing null */
948 strncpy(pSMB->DirName, dirName, name_len);
949 }
950
951 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000952 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 pSMB->ByteCount = cpu_to_le16(name_len + 1);
954 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
955 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -0700956 cifs_stats_inc(&tcon->num_rmdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +0000957 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000958 cFYI(1, "Error in RMDir = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 cifs_buf_release(pSMB);
961 if (rc == -EAGAIN)
962 goto RmDirRetry;
963 return rc;
964}
965
966int
Steve French96daf2b2011-05-27 04:34:02 +0000967CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
Steve French737b7582005-04-28 22:41:06 -0700968 const char *name, const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969{
970 int rc = 0;
971 CREATE_DIRECTORY_REQ *pSMB = NULL;
972 CREATE_DIRECTORY_RSP *pSMBr = NULL;
973 int bytes_returned;
974 int name_len;
975
Joe Perchesb6b38f72010-04-21 03:50:45 +0000976 cFYI(1, "In CIFSSMBMkDir");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977MkDirRetry:
978 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
979 (void **) &pSMBr);
980 if (rc)
981 return rc;
982
983 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve French50c2f752007-07-13 00:33:32 +0000984 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
Steve French737b7582005-04-28 22:41:06 -0700985 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 name_len++; /* trailing null */
987 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700988 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 name_len = strnlen(name, PATH_MAX);
990 name_len++; /* trailing null */
991 strncpy(pSMB->DirName, name, name_len);
992 }
993
994 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000995 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 pSMB->ByteCount = cpu_to_le16(name_len + 1);
997 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
998 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -0700999 cifs_stats_inc(&tcon->num_mkdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +00001000 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001001 cFYI(1, "Error in Mkdir = %d", rc);
Steve Frencha5a2b482005-08-20 21:42:53 -07001002
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 cifs_buf_release(pSMB);
1004 if (rc == -EAGAIN)
1005 goto MkDirRetry;
1006 return rc;
1007}
1008
Steve French2dd29d32007-04-23 22:07:35 +00001009int
Steve French96daf2b2011-05-27 04:34:02 +00001010CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
Steve Frenchad7a2922008-02-07 23:25:02 +00001011 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
Steve French50c2f752007-07-13 00:33:32 +00001012 __u32 *pOplock, const char *name,
Steve French2dd29d32007-04-23 22:07:35 +00001013 const struct nls_table *nls_codepage, int remap)
1014{
1015 TRANSACTION2_SPI_REQ *pSMB = NULL;
1016 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1017 int name_len;
1018 int rc = 0;
1019 int bytes_returned = 0;
Steve French2dd29d32007-04-23 22:07:35 +00001020 __u16 params, param_offset, offset, byte_count, count;
Steve Frenchad7a2922008-02-07 23:25:02 +00001021 OPEN_PSX_REQ *pdata;
1022 OPEN_PSX_RSP *psx_rsp;
Steve French2dd29d32007-04-23 22:07:35 +00001023
Joe Perchesb6b38f72010-04-21 03:50:45 +00001024 cFYI(1, "In POSIX Create");
Steve French2dd29d32007-04-23 22:07:35 +00001025PsxCreat:
1026 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1027 (void **) &pSMBr);
1028 if (rc)
1029 return rc;
1030
1031 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1032 name_len =
1033 cifsConvertToUCS((__le16 *) pSMB->FileName, name,
1034 PATH_MAX, nls_codepage, remap);
1035 name_len++; /* trailing null */
1036 name_len *= 2;
1037 } else { /* BB improve the check for buffer overruns BB */
1038 name_len = strnlen(name, PATH_MAX);
1039 name_len++; /* trailing null */
1040 strncpy(pSMB->FileName, name, name_len);
1041 }
1042
1043 params = 6 + name_len;
1044 count = sizeof(OPEN_PSX_REQ);
1045 pSMB->MaxParameterCount = cpu_to_le16(2);
1046 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1047 pSMB->MaxSetupCount = 0;
1048 pSMB->Reserved = 0;
1049 pSMB->Flags = 0;
1050 pSMB->Timeout = 0;
1051 pSMB->Reserved2 = 0;
1052 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00001053 InformationLevel) - 4;
Steve French2dd29d32007-04-23 22:07:35 +00001054 offset = param_offset + params;
Steve French2dd29d32007-04-23 22:07:35 +00001055 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001056 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
Steve French2dd29d32007-04-23 22:07:35 +00001057 pdata->Permissions = cpu_to_le64(mode);
Steve French50c2f752007-07-13 00:33:32 +00001058 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
Steve French2dd29d32007-04-23 22:07:35 +00001059 pdata->OpenFlags = cpu_to_le32(*pOplock);
1060 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1061 pSMB->DataOffset = cpu_to_le16(offset);
1062 pSMB->SetupCount = 1;
1063 pSMB->Reserved3 = 0;
1064 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1065 byte_count = 3 /* pad */ + params + count;
1066
1067 pSMB->DataCount = cpu_to_le16(count);
1068 pSMB->ParameterCount = cpu_to_le16(params);
1069 pSMB->TotalDataCount = pSMB->DataCount;
1070 pSMB->TotalParameterCount = pSMB->ParameterCount;
1071 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1072 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001073 inc_rfc1001_len(pSMB, byte_count);
Steve French2dd29d32007-04-23 22:07:35 +00001074 pSMB->ByteCount = cpu_to_le16(byte_count);
1075 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1076 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1077 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001078 cFYI(1, "Posix create returned %d", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001079 goto psx_create_err;
1080 }
1081
Joe Perchesb6b38f72010-04-21 03:50:45 +00001082 cFYI(1, "copying inode info");
Steve French2dd29d32007-04-23 22:07:35 +00001083 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1084
Jeff Layton820a8032011-05-04 08:05:26 -04001085 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
Steve French2dd29d32007-04-23 22:07:35 +00001086 rc = -EIO; /* bad smb */
1087 goto psx_create_err;
1088 }
1089
1090 /* copy return information to pRetData */
Steve French50c2f752007-07-13 00:33:32 +00001091 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
Steve French2dd29d32007-04-23 22:07:35 +00001092 + le16_to_cpu(pSMBr->t2.DataOffset));
Steve French50c2f752007-07-13 00:33:32 +00001093
Steve French2dd29d32007-04-23 22:07:35 +00001094 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
Steve French790fe572007-07-07 19:25:05 +00001095 if (netfid)
Steve French2dd29d32007-04-23 22:07:35 +00001096 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1097 /* Let caller know file was created so we can set the mode. */
1098 /* Do we care about the CreateAction in any other cases? */
Steve French790fe572007-07-07 19:25:05 +00001099 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
Steve French2dd29d32007-04-23 22:07:35 +00001100 *pOplock |= CIFS_CREATE_ACTION;
1101 /* check to make sure response data is there */
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001102 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1103 pRetData->Type = cpu_to_le32(-1); /* unknown */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001104 cFYI(DBG2, "unknown type");
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001105 } else {
Jeff Layton820a8032011-05-04 08:05:26 -04001106 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
Steve French2dd29d32007-04-23 22:07:35 +00001107 + sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001108 cERROR(1, "Open response data too small");
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001109 pRetData->Type = cpu_to_le32(-1);
Steve French2dd29d32007-04-23 22:07:35 +00001110 goto psx_create_err;
1111 }
Steve French50c2f752007-07-13 00:33:32 +00001112 memcpy((char *) pRetData,
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001113 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
Steve French26f57362007-08-30 22:09:15 +00001114 sizeof(FILE_UNIX_BASIC_INFO));
Steve French2dd29d32007-04-23 22:07:35 +00001115 }
Steve French2dd29d32007-04-23 22:07:35 +00001116
1117psx_create_err:
1118 cifs_buf_release(pSMB);
1119
Steve French65bc98b2009-07-10 15:27:25 +00001120 if (posix_flags & SMB_O_DIRECTORY)
1121 cifs_stats_inc(&tcon->num_posixmkdirs);
1122 else
1123 cifs_stats_inc(&tcon->num_posixopens);
Steve French2dd29d32007-04-23 22:07:35 +00001124
1125 if (rc == -EAGAIN)
1126 goto PsxCreat;
1127
Steve French50c2f752007-07-13 00:33:32 +00001128 return rc;
Steve French2dd29d32007-04-23 22:07:35 +00001129}
1130
Steve Frencha9d02ad2005-08-24 23:06:05 -07001131static __u16 convert_disposition(int disposition)
1132{
1133 __u16 ofun = 0;
1134
1135 switch (disposition) {
1136 case FILE_SUPERSEDE:
1137 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1138 break;
1139 case FILE_OPEN:
1140 ofun = SMBOPEN_OAPPEND;
1141 break;
1142 case FILE_CREATE:
1143 ofun = SMBOPEN_OCREATE;
1144 break;
1145 case FILE_OPEN_IF:
1146 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1147 break;
1148 case FILE_OVERWRITE:
1149 ofun = SMBOPEN_OTRUNC;
1150 break;
1151 case FILE_OVERWRITE_IF:
1152 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1153 break;
1154 default:
Joe Perchesb6b38f72010-04-21 03:50:45 +00001155 cFYI(1, "unknown disposition %d", disposition);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001156 ofun = SMBOPEN_OAPPEND; /* regular open */
1157 }
1158 return ofun;
1159}
1160
Jeff Layton35fc37d2008-05-14 10:22:03 -07001161static int
1162access_flags_to_smbopen_mode(const int access_flags)
1163{
1164 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1165
1166 if (masked_flags == GENERIC_READ)
1167 return SMBOPEN_READ;
1168 else if (masked_flags == GENERIC_WRITE)
1169 return SMBOPEN_WRITE;
1170
1171 /* just go for read/write */
1172 return SMBOPEN_READWRITE;
1173}
1174
Steve Frencha9d02ad2005-08-24 23:06:05 -07001175int
Steve French96daf2b2011-05-27 04:34:02 +00001176SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001177 const char *fileName, const int openDisposition,
Steve Frenchad7a2922008-02-07 23:25:02 +00001178 const int access_flags, const int create_options, __u16 *netfid,
1179 int *pOplock, FILE_ALL_INFO *pfile_info,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001180 const struct nls_table *nls_codepage, int remap)
1181{
1182 int rc = -EACCES;
1183 OPENX_REQ *pSMB = NULL;
1184 OPENX_RSP *pSMBr = NULL;
1185 int bytes_returned;
1186 int name_len;
1187 __u16 count;
1188
1189OldOpenRetry:
1190 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1191 (void **) &pSMBr);
1192 if (rc)
1193 return rc;
1194
1195 pSMB->AndXCommand = 0xFF; /* none */
1196
1197 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1198 count = 1; /* account for one byte pad to word boundary */
1199 name_len =
1200 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1201 fileName, PATH_MAX, nls_codepage, remap);
1202 name_len++; /* trailing null */
1203 name_len *= 2;
1204 } else { /* BB improve check for buffer overruns BB */
1205 count = 0; /* no pad */
1206 name_len = strnlen(fileName, PATH_MAX);
1207 name_len++; /* trailing null */
1208 strncpy(pSMB->fileName, fileName, name_len);
1209 }
1210 if (*pOplock & REQ_OPLOCK)
1211 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001212 else if (*pOplock & REQ_BATCHOPLOCK)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001213 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001214
Steve Frencha9d02ad2005-08-24 23:06:05 -07001215 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
Jeff Layton35fc37d2008-05-14 10:22:03 -07001216 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001217 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1218 /* set file as system file if special file such
1219 as fifo and server expecting SFU style and
1220 no Unix extensions */
1221
Steve French790fe572007-07-07 19:25:05 +00001222 if (create_options & CREATE_OPTION_SPECIAL)
1223 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
Steve Frenchad7a2922008-02-07 23:25:02 +00001224 else /* BB FIXME BB */
1225 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001226
Jeff Layton67750fb2008-05-09 22:28:02 +00001227 if (create_options & CREATE_OPTION_READONLY)
1228 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001229
1230 /* BB FIXME BB */
Steve French50c2f752007-07-13 00:33:32 +00001231/* pSMB->CreateOptions = cpu_to_le32(create_options &
1232 CREATE_OPTIONS_MASK); */
Steve Frencha9d02ad2005-08-24 23:06:05 -07001233 /* BB FIXME END BB */
Steve French3e87d802005-09-18 20:49:21 -07001234
1235 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
Steve French70ca7342005-09-22 16:32:06 -07001236 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001237 count += name_len;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001238 inc_rfc1001_len(pSMB, count);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001239
1240 pSMB->ByteCount = cpu_to_le16(count);
1241 /* long_op set to 1 to allow for oplock break timeouts */
1242 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Jeff Layton77499812011-01-11 07:24:23 -05001243 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001244 cifs_stats_inc(&tcon->num_opens);
1245 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001246 cFYI(1, "Error in Open = %d", rc);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001247 } else {
1248 /* BB verify if wct == 15 */
1249
Steve French582d21e2008-05-13 04:54:12 +00001250/* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
Steve Frencha9d02ad2005-08-24 23:06:05 -07001251
1252 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1253 /* Let caller know file was created so we can set the mode. */
1254 /* Do we care about the CreateAction in any other cases? */
1255 /* BB FIXME BB */
Steve French790fe572007-07-07 19:25:05 +00001256/* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001257 *pOplock |= CIFS_CREATE_ACTION; */
1258 /* BB FIXME END */
1259
Steve French790fe572007-07-07 19:25:05 +00001260 if (pfile_info) {
Steve Frencha9d02ad2005-08-24 23:06:05 -07001261 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1262 pfile_info->LastAccessTime = 0; /* BB fixme */
1263 pfile_info->LastWriteTime = 0; /* BB fixme */
1264 pfile_info->ChangeTime = 0; /* BB fixme */
Steve French70ca7342005-09-22 16:32:06 -07001265 pfile_info->Attributes =
Steve French50c2f752007-07-13 00:33:32 +00001266 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001267 /* the file_info buf is endian converted by caller */
Steve French70ca7342005-09-22 16:32:06 -07001268 pfile_info->AllocationSize =
1269 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1270 pfile_info->EndOfFile = pfile_info->AllocationSize;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001271 pfile_info->NumberOfLinks = cpu_to_le32(1);
Jeff Layton9a8165f2008-10-17 21:03:20 -04001272 pfile_info->DeletePending = 0;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001273 }
1274 }
1275
1276 cifs_buf_release(pSMB);
1277 if (rc == -EAGAIN)
1278 goto OldOpenRetry;
1279 return rc;
1280}
1281
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282int
Steve French96daf2b2011-05-27 04:34:02 +00001283CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 const char *fileName, const int openDisposition,
Steve Frenchad7a2922008-02-07 23:25:02 +00001285 const int access_flags, const int create_options, __u16 *netfid,
1286 int *pOplock, FILE_ALL_INFO *pfile_info,
Steve French737b7582005-04-28 22:41:06 -07001287 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288{
1289 int rc = -EACCES;
1290 OPEN_REQ *pSMB = NULL;
1291 OPEN_RSP *pSMBr = NULL;
1292 int bytes_returned;
1293 int name_len;
1294 __u16 count;
1295
1296openRetry:
1297 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1298 (void **) &pSMBr);
1299 if (rc)
1300 return rc;
1301
1302 pSMB->AndXCommand = 0xFF; /* none */
1303
1304 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1305 count = 1; /* account for one byte pad to word boundary */
1306 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05001307 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
Steve French737b7582005-04-28 22:41:06 -07001308 fileName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 name_len++; /* trailing null */
1310 name_len *= 2;
1311 pSMB->NameLength = cpu_to_le16(name_len);
Steve French09d1db52005-04-28 22:41:08 -07001312 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 count = 0; /* no pad */
1314 name_len = strnlen(fileName, PATH_MAX);
1315 name_len++; /* trailing null */
1316 pSMB->NameLength = cpu_to_le16(name_len);
1317 strncpy(pSMB->fileName, fileName, name_len);
1318 }
1319 if (*pOplock & REQ_OPLOCK)
1320 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001321 else if (*pOplock & REQ_BATCHOPLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1324 pSMB->AllocationSize = 0;
Steve Frencheda3c022005-07-21 15:20:28 -07001325 /* set file as system file if special file such
1326 as fifo and server expecting SFU style and
1327 no Unix extensions */
Steve French790fe572007-07-07 19:25:05 +00001328 if (create_options & CREATE_OPTION_SPECIAL)
Steve Frencheda3c022005-07-21 15:20:28 -07001329 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1330 else
1331 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
Jeff Layton67750fb2008-05-09 22:28:02 +00001332
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 /* XP does not handle ATTR_POSIX_SEMANTICS */
1334 /* but it helps speed up case sensitive checks for other
1335 servers such as Samba */
1336 if (tcon->ses->capabilities & CAP_UNIX)
1337 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1338
Jeff Layton67750fb2008-05-09 22:28:02 +00001339 if (create_options & CREATE_OPTION_READONLY)
1340 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1343 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
Steve Frencheda3c022005-07-21 15:20:28 -07001344 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
Steve French09d1db52005-04-28 22:41:08 -07001345 /* BB Expirement with various impersonation levels and verify */
1346 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 pSMB->SecurityFlags =
1348 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1349
1350 count += name_len;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001351 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
1353 pSMB->ByteCount = cpu_to_le16(count);
1354 /* long_op set to 1 to allow for oplock break timeouts */
1355 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Jeff Layton77499812011-01-11 07:24:23 -05001356 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07001357 cifs_stats_inc(&tcon->num_opens);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001359 cFYI(1, "Error in Open = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 } else {
Steve French09d1db52005-04-28 22:41:08 -07001361 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1363 /* Let caller know file was created so we can set the mode. */
1364 /* Do we care about the CreateAction in any other cases? */
Steve French790fe572007-07-07 19:25:05 +00001365 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
Steve French50c2f752007-07-13 00:33:32 +00001366 *pOplock |= CIFS_CREATE_ACTION;
Steve French790fe572007-07-07 19:25:05 +00001367 if (pfile_info) {
Steve French61e74802008-12-03 00:57:54 +00001368 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1369 36 /* CreationTime to Attributes */);
1370 /* the file_info buf is endian converted by caller */
1371 pfile_info->AllocationSize = pSMBr->AllocationSize;
1372 pfile_info->EndOfFile = pSMBr->EndOfFile;
1373 pfile_info->NumberOfLinks = cpu_to_le32(1);
1374 pfile_info->DeletePending = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 }
Steve Frencha5a2b482005-08-20 21:42:53 -07001377
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 cifs_buf_release(pSMB);
1379 if (rc == -EAGAIN)
1380 goto openRetry;
1381 return rc;
1382}
1383
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001384struct cifs_readdata *
1385cifs_readdata_alloc(unsigned int nr_pages)
1386{
1387 struct cifs_readdata *rdata;
1388
1389 /* readdata + 1 kvec for each page */
1390 rdata = kzalloc(sizeof(*rdata) +
1391 sizeof(struct kvec) * nr_pages, GFP_KERNEL);
1392 if (rdata != NULL) {
1393 INIT_WORK(&rdata->work, cifs_readv_complete);
1394 INIT_LIST_HEAD(&rdata->pages);
1395 }
1396 return rdata;
1397}
1398
1399void
1400cifs_readdata_free(struct cifs_readdata *rdata)
1401{
1402 cifsFileInfo_put(rdata->cfile);
1403 kfree(rdata);
1404}
1405
1406/*
1407 * Discard any remaining data in the current SMB. To do this, we borrow the
1408 * current bigbuf.
1409 */
1410static int
1411cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1412{
1413 READ_RSP *rsp = (READ_RSP *)server->smallbuf;
1414 unsigned int rfclen = be32_to_cpu(rsp->hdr.smb_buf_length);
1415 int remaining = rfclen + 4 - server->total_read;
1416 struct cifs_readdata *rdata = mid->callback_data;
1417
1418 while (remaining > 0) {
1419 int length;
1420
1421 length = cifs_read_from_socket(server, server->bigbuf,
1422 min_t(unsigned int, remaining,
1423 CIFSMaxBufSize + MAX_CIFS_HDR_SIZE));
1424 if (length < 0)
1425 return length;
1426 server->total_read += length;
1427 remaining -= length;
1428 }
1429
1430 dequeue_mid(mid, rdata->result);
1431 return 0;
1432}
1433
1434static int
1435cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1436{
1437 int length, len;
1438 unsigned int data_offset, remaining, data_len;
1439 struct cifs_readdata *rdata = mid->callback_data;
1440 READ_RSP *rsp = (READ_RSP *)server->smallbuf;
1441 unsigned int rfclen = be32_to_cpu(rsp->hdr.smb_buf_length) + 4;
1442 u64 eof;
1443 pgoff_t eof_index;
1444 struct page *page, *tpage;
1445
1446 cFYI(1, "%s: mid=%u offset=%llu bytes=%u", __func__,
1447 mid->mid, rdata->offset, rdata->bytes);
1448
1449 /*
1450 * read the rest of READ_RSP header (sans Data array), or whatever we
1451 * can if there's not enough data. At this point, we've read down to
1452 * the Mid.
1453 */
1454 len = min_t(unsigned int, rfclen, sizeof(*rsp)) -
1455 sizeof(struct smb_hdr) + 1;
1456
1457 rdata->iov[0].iov_base = server->smallbuf + sizeof(struct smb_hdr) - 1;
1458 rdata->iov[0].iov_len = len;
1459
1460 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1461 if (length < 0)
1462 return length;
1463 server->total_read += length;
1464
1465 /* Was the SMB read successful? */
1466 rdata->result = map_smb_to_linux_error(&rsp->hdr, false);
1467 if (rdata->result != 0) {
1468 cFYI(1, "%s: server returned error %d", __func__,
1469 rdata->result);
1470 return cifs_readv_discard(server, mid);
1471 }
1472
1473 /* Is there enough to get to the rest of the READ_RSP header? */
1474 if (server->total_read < sizeof(READ_RSP)) {
1475 cFYI(1, "%s: server returned short header. got=%u expected=%zu",
1476 __func__, server->total_read, sizeof(READ_RSP));
1477 rdata->result = -EIO;
1478 return cifs_readv_discard(server, mid);
1479 }
1480
1481 data_offset = le16_to_cpu(rsp->DataOffset) + 4;
1482 if (data_offset < server->total_read) {
1483 /*
1484 * win2k8 sometimes sends an offset of 0 when the read
1485 * is beyond the EOF. Treat it as if the data starts just after
1486 * the header.
1487 */
1488 cFYI(1, "%s: data offset (%u) inside read response header",
1489 __func__, data_offset);
1490 data_offset = server->total_read;
1491 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1492 /* data_offset is beyond the end of smallbuf */
1493 cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
1494 __func__, data_offset);
1495 rdata->result = -EIO;
1496 return cifs_readv_discard(server, mid);
1497 }
1498
1499 cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
1500 server->total_read, data_offset);
1501
1502 len = data_offset - server->total_read;
1503 if (len > 0) {
1504 /* read any junk before data into the rest of smallbuf */
1505 rdata->iov[0].iov_base = server->smallbuf + server->total_read;
1506 rdata->iov[0].iov_len = len;
1507 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1508 if (length < 0)
1509 return length;
1510 server->total_read += length;
1511 }
1512
1513 /* set up first iov for signature check */
1514 rdata->iov[0].iov_base = server->smallbuf;
1515 rdata->iov[0].iov_len = server->total_read;
1516 cFYI(1, "0: iov_base=%p iov_len=%zu",
1517 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1518
1519 /* how much data is in the response? */
1520 data_len = le16_to_cpu(rsp->DataLengthHigh) << 16;
1521 data_len += le16_to_cpu(rsp->DataLength);
1522 if (data_offset + data_len > rfclen) {
1523 /* data_len is corrupt -- discard frame */
1524 rdata->result = -EIO;
1525 return cifs_readv_discard(server, mid);
1526 }
1527
1528 /* marshal up the page array */
1529 len = 0;
1530 remaining = data_len;
1531 rdata->nr_iov = 1;
1532
1533 /* determine the eof that the server (probably) has */
1534 eof = CIFS_I(rdata->mapping->host)->server_eof;
1535 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
1536 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
1537
1538 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1539 if (remaining >= PAGE_CACHE_SIZE) {
1540 /* enough data to fill the page */
1541 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1542 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
1543 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1544 rdata->nr_iov, page->index,
1545 rdata->iov[rdata->nr_iov].iov_base,
1546 rdata->iov[rdata->nr_iov].iov_len);
1547 ++rdata->nr_iov;
1548 len += PAGE_CACHE_SIZE;
1549 remaining -= PAGE_CACHE_SIZE;
1550 } else if (remaining > 0) {
1551 /* enough for partial page, fill and zero the rest */
1552 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1553 rdata->iov[rdata->nr_iov].iov_len = remaining;
1554 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1555 rdata->nr_iov, page->index,
1556 rdata->iov[rdata->nr_iov].iov_base,
1557 rdata->iov[rdata->nr_iov].iov_len);
1558 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
1559 '\0', PAGE_CACHE_SIZE - remaining);
1560 ++rdata->nr_iov;
1561 len += remaining;
1562 remaining = 0;
1563 } else if (page->index > eof_index) {
1564 /*
1565 * The VFS will not try to do readahead past the
1566 * i_size, but it's possible that we have outstanding
1567 * writes with gaps in the middle and the i_size hasn't
1568 * caught up yet. Populate those with zeroed out pages
1569 * to prevent the VFS from repeatedly attempting to
1570 * fill them until the writes are flushed.
1571 */
1572 zero_user(page, 0, PAGE_CACHE_SIZE);
1573 list_del(&page->lru);
1574 lru_cache_add_file(page);
1575 flush_dcache_page(page);
1576 SetPageUptodate(page);
1577 unlock_page(page);
1578 page_cache_release(page);
1579 } else {
1580 /* no need to hold page hostage */
1581 list_del(&page->lru);
1582 lru_cache_add_file(page);
1583 unlock_page(page);
1584 page_cache_release(page);
1585 }
1586 }
1587
1588 /* issue the read if we have any iovecs left to fill */
1589 if (rdata->nr_iov > 1) {
1590 length = cifs_readv_from_socket(server, &rdata->iov[1],
1591 rdata->nr_iov - 1, len);
1592 if (length < 0)
1593 return length;
1594 server->total_read += length;
1595 } else {
1596 length = 0;
1597 }
1598
1599 rdata->bytes = length;
1600
1601 cFYI(1, "total_read=%u rfclen=%u remaining=%u", server->total_read,
1602 rfclen, remaining);
1603
1604 /* discard anything left over */
1605 if (server->total_read < rfclen)
1606 return cifs_readv_discard(server, mid);
1607
1608 dequeue_mid(mid, false);
1609 return length;
1610}
1611
1612static void
1613cifs_readv_complete(struct work_struct *work)
1614{
1615 struct cifs_readdata *rdata = container_of(work,
1616 struct cifs_readdata, work);
1617 struct page *page, *tpage;
1618
1619 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1620 list_del(&page->lru);
1621 lru_cache_add_file(page);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001622
1623 if (rdata->result == 0) {
Pavel Shilovskya2d6b6c2011-10-21 10:14:04 +04001624 kunmap(page);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001625 flush_dcache_page(page);
1626 SetPageUptodate(page);
1627 }
1628
1629 unlock_page(page);
1630
1631 if (rdata->result == 0)
1632 cifs_readpage_to_fscache(rdata->mapping->host, page);
1633
1634 page_cache_release(page);
1635 }
1636 cifs_readdata_free(rdata);
1637}
1638
1639static void
1640cifs_readv_callback(struct mid_q_entry *mid)
1641{
1642 struct cifs_readdata *rdata = mid->callback_data;
1643 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1644 struct TCP_Server_Info *server = tcon->ses->server;
1645
1646 cFYI(1, "%s: mid=%u state=%d result=%d bytes=%u", __func__,
1647 mid->mid, mid->midState, rdata->result, rdata->bytes);
1648
1649 switch (mid->midState) {
1650 case MID_RESPONSE_RECEIVED:
1651 /* result already set, check signature */
1652 if (server->sec_mode &
1653 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1654 if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
1655 server, mid->sequence_number + 1))
1656 cERROR(1, "Unexpected SMB signature");
1657 }
1658 /* FIXME: should this be counted toward the initiating task? */
1659 task_io_account_read(rdata->bytes);
1660 cifs_stats_bytes_read(tcon, rdata->bytes);
1661 break;
1662 case MID_REQUEST_SUBMITTED:
1663 case MID_RETRY_NEEDED:
1664 rdata->result = -EAGAIN;
1665 break;
1666 default:
1667 rdata->result = -EIO;
1668 }
1669
1670 queue_work(system_nrt_wq, &rdata->work);
1671 DeleteMidQEntry(mid);
1672 atomic_dec(&server->inFlight);
1673 wake_up(&server->request_q);
1674}
1675
1676/* cifs_async_readv - send an async write, and set up mid to handle result */
1677int
1678cifs_async_readv(struct cifs_readdata *rdata)
1679{
1680 int rc;
1681 READ_REQ *smb = NULL;
1682 int wct;
1683 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1684
1685 cFYI(1, "%s: offset=%llu bytes=%u", __func__,
1686 rdata->offset, rdata->bytes);
1687
1688 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1689 wct = 12;
1690 else {
1691 wct = 10; /* old style read */
1692 if ((rdata->offset >> 32) > 0) {
1693 /* can not handle this big offset for old */
1694 return -EIO;
1695 }
1696 }
1697
1698 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1699 if (rc)
1700 return rc;
1701
1702 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1703 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1704
1705 smb->AndXCommand = 0xFF; /* none */
1706 smb->Fid = rdata->cfile->netfid;
1707 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1708 if (wct == 12)
1709 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1710 smb->Remaining = 0;
1711 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1712 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1713 if (wct == 12)
1714 smb->ByteCount = 0;
1715 else {
1716 /* old style read */
1717 struct smb_com_readx_req *smbr =
1718 (struct smb_com_readx_req *)smb;
1719 smbr->ByteCount = 0;
1720 }
1721
1722 /* 4 for RFC1001 length + 1 for BCC */
1723 rdata->iov[0].iov_base = smb;
1724 rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1725
1726 rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
1727 cifs_readv_receive, cifs_readv_callback,
1728 rdata, false);
1729
1730 if (rc == 0)
1731 cifs_stats_inc(&tcon->num_reads);
1732
1733 cifs_small_buf_release(smb);
1734 return rc;
1735}
1736
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737int
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001738CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
Steve French50c2f752007-07-13 00:33:32 +00001739 char **buf, int *pbuf_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740{
1741 int rc = -EACCES;
1742 READ_REQ *pSMB = NULL;
1743 READ_RSP *pSMBr = NULL;
1744 char *pReadData = NULL;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001745 int wct;
Steve Frenchec637e32005-12-12 20:53:18 -08001746 int resp_buf_type = 0;
1747 struct kvec iov[1];
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001748 __u32 pid = io_parms->pid;
1749 __u16 netfid = io_parms->netfid;
1750 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001751 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001752 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753
Joe Perchesb6b38f72010-04-21 03:50:45 +00001754 cFYI(1, "Reading %d bytes on fid %d", count, netfid);
Steve French790fe572007-07-07 19:25:05 +00001755 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001756 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001757 else {
Steve Frenchbfa0d752005-08-31 21:50:37 -07001758 wct = 10; /* old style read */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001759 if ((offset >> 32) > 0) {
Steve French4c3130e2008-12-09 00:28:16 +00001760 /* can not handle this big offset for old */
1761 return -EIO;
1762 }
1763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
1765 *nbytes = 0;
Steve Frenchec637e32005-12-12 20:53:18 -08001766 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 if (rc)
1768 return rc;
1769
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001770 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1771 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1772
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 /* tcon and ses pointer are checked in smb_init */
1774 if (tcon->ses->server == NULL)
1775 return -ECONNABORTED;
1776
Steve Frenchec637e32005-12-12 20:53:18 -08001777 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 pSMB->Fid = netfid;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001779 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001780 if (wct == 12)
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001781 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve Frenchbfa0d752005-08-31 21:50:37 -07001782
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 pSMB->Remaining = 0;
1784 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1785 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
Steve French790fe572007-07-07 19:25:05 +00001786 if (wct == 12)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001787 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1788 else {
1789 /* old style read */
Steve French50c2f752007-07-13 00:33:32 +00001790 struct smb_com_readx_req *pSMBW =
Steve Frenchbfa0d752005-08-31 21:50:37 -07001791 (struct smb_com_readx_req *)pSMB;
Steve Frenchec637e32005-12-12 20:53:18 -08001792 pSMBW->ByteCount = 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001793 }
Steve Frenchec637e32005-12-12 20:53:18 -08001794
1795 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001796 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve Frencha761ac52007-10-18 21:45:27 +00001797 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
Jeff Layton77499812011-01-11 07:24:23 -05001798 &resp_buf_type, CIFS_LOG_ERROR);
Steve Frencha4544342005-08-24 13:59:35 -07001799 cifs_stats_inc(&tcon->num_reads);
Steve Frenchec637e32005-12-12 20:53:18 -08001800 pSMBr = (READ_RSP *)iov[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001802 cERROR(1, "Send error in read = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 } else {
1804 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1805 data_length = data_length << 16;
1806 data_length += le16_to_cpu(pSMBr->DataLength);
1807 *nbytes = data_length;
1808
1809 /*check that DataLength would not go beyond end of SMB */
Steve Frenchec637e32005-12-12 20:53:18 -08001810 if ((data_length > CIFSMaxBufSize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 || (data_length > count)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001812 cFYI(1, "bad length %d for count %d",
1813 data_length, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 rc = -EIO;
1815 *nbytes = 0;
1816 } else {
Steve Frenchec637e32005-12-12 20:53:18 -08001817 pReadData = (char *) (&pSMBr->hdr.Protocol) +
Steve French26f57362007-08-30 22:09:15 +00001818 le16_to_cpu(pSMBr->DataOffset);
1819/* if (rc = copy_to_user(buf, pReadData, data_length)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001820 cERROR(1, "Faulting on read rc = %d",rc);
Steve French50c2f752007-07-13 00:33:32 +00001821 rc = -EFAULT;
Steve French26f57362007-08-30 22:09:15 +00001822 }*/ /* can not use copy_to_user when using page cache*/
Steve French790fe572007-07-07 19:25:05 +00001823 if (*buf)
Steve French50c2f752007-07-13 00:33:32 +00001824 memcpy(*buf, pReadData, data_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 }
1826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
Steve French4b8f9302006-02-26 16:41:18 +00001828/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00001829 if (*buf) {
1830 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001831 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001832 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001833 cifs_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001834 } else if (resp_buf_type != CIFS_NO_BUFFER) {
Steve French50c2f752007-07-13 00:33:32 +00001835 /* return buffer to caller to free */
1836 *buf = iov[0].iov_base;
Steve French790fe572007-07-07 19:25:05 +00001837 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001838 *pbuf_type = CIFS_SMALL_BUFFER;
Steve French790fe572007-07-07 19:25:05 +00001839 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001840 *pbuf_type = CIFS_LARGE_BUFFER;
Steve French6cec2ae2006-02-22 17:31:52 -06001841 } /* else no valid buffer on return - leave as null */
Steve Frenchec637e32005-12-12 20:53:18 -08001842
1843 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 since file handle passed in no longer valid */
1845 return rc;
1846}
1847
Steve Frenchec637e32005-12-12 20:53:18 -08001848
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849int
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001850CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
1851 unsigned int *nbytes, const char *buf,
Steve French50c2f752007-07-13 00:33:32 +00001852 const char __user *ubuf, const int long_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853{
1854 int rc = -EACCES;
1855 WRITE_REQ *pSMB = NULL;
1856 WRITE_RSP *pSMBr = NULL;
Steve French1c955182005-08-30 20:58:07 -07001857 int bytes_returned, wct;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 __u32 bytes_sent;
1859 __u16 byte_count;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001860 __u32 pid = io_parms->pid;
1861 __u16 netfid = io_parms->netfid;
1862 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001863 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001864 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Steve Frencha24e2d72010-04-03 17:20:21 +00001866 *nbytes = 0;
1867
Joe Perchesb6b38f72010-04-21 03:50:45 +00001868 /* cFYI(1, "write at %lld %d bytes", offset, count);*/
Steve French790fe572007-07-07 19:25:05 +00001869 if (tcon->ses == NULL)
Steve French1c955182005-08-30 20:58:07 -07001870 return -ECONNABORTED;
1871
Steve French790fe572007-07-07 19:25:05 +00001872 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve French1c955182005-08-30 20:58:07 -07001873 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00001874 else {
Steve French1c955182005-08-30 20:58:07 -07001875 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001876 if ((offset >> 32) > 0) {
1877 /* can not handle big offset for old srv */
1878 return -EIO;
1879 }
1880 }
Steve French1c955182005-08-30 20:58:07 -07001881
1882 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 (void **) &pSMBr);
1884 if (rc)
1885 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001886
1887 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1888 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1889
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 /* tcon and ses pointer are checked in smb_init */
1891 if (tcon->ses->server == NULL)
1892 return -ECONNABORTED;
1893
1894 pSMB->AndXCommand = 0xFF; /* none */
1895 pSMB->Fid = netfid;
1896 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001897 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001898 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve French50c2f752007-07-13 00:33:32 +00001899
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 pSMB->Reserved = 0xFFFFFFFF;
1901 pSMB->WriteMode = 0;
1902 pSMB->Remaining = 0;
1903
Steve French50c2f752007-07-13 00:33:32 +00001904 /* Can increase buffer size if buffer is big enough in some cases ie we
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 can send more if LARGE_WRITE_X capability returned by the server and if
1906 our buffer is big enough or if we convert to iovecs on socket writes
1907 and eliminate the copy to the CIFS buffer */
Steve French790fe572007-07-07 19:25:05 +00001908 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1910 } else {
1911 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1912 & ~0xFF;
1913 }
1914
1915 if (bytes_sent > count)
1916 bytes_sent = count;
1917 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00001918 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Steve French790fe572007-07-07 19:25:05 +00001919 if (buf)
Steve French61e74802008-12-03 00:57:54 +00001920 memcpy(pSMB->Data, buf, bytes_sent);
Steve French790fe572007-07-07 19:25:05 +00001921 else if (ubuf) {
1922 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 cifs_buf_release(pSMB);
1924 return -EFAULT;
1925 }
Steve Frenche30dcf32005-09-20 20:49:16 -07001926 } else if (count != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 /* No buffer */
1928 cifs_buf_release(pSMB);
1929 return -EINVAL;
Steve Frenche30dcf32005-09-20 20:49:16 -07001930 } /* else setting file size with write of zero bytes */
Steve French790fe572007-07-07 19:25:05 +00001931 if (wct == 14)
Steve Frenche30dcf32005-09-20 20:49:16 -07001932 byte_count = bytes_sent + 1; /* pad */
Steve Frenchad7a2922008-02-07 23:25:02 +00001933 else /* wct == 12 */
Steve Frenche30dcf32005-09-20 20:49:16 -07001934 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
Steve Frenchad7a2922008-02-07 23:25:02 +00001935
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1937 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001938 inc_rfc1001_len(pSMB, byte_count);
Steve French1c955182005-08-30 20:58:07 -07001939
Steve French790fe572007-07-07 19:25:05 +00001940 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001941 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00001942 else { /* old style write has byte count 4 bytes earlier
1943 so 4 bytes pad */
1944 struct smb_com_writex_req *pSMBW =
Steve French1c955182005-08-30 20:58:07 -07001945 (struct smb_com_writex_req *)pSMB;
1946 pSMBW->ByteCount = cpu_to_le16(byte_count);
1947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1950 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
Steve Frencha4544342005-08-24 13:59:35 -07001951 cifs_stats_inc(&tcon->num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00001953 cFYI(1, "Send error in write = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 } else {
1955 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1956 *nbytes = (*nbytes) << 16;
1957 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05301958
1959 /*
1960 * Mask off high 16 bits when bytes written as returned by the
1961 * server is greater than bytes requested by the client. Some
1962 * OS/2 servers are known to set incorrect CountHigh values.
1963 */
1964 if (*nbytes > count)
1965 *nbytes &= 0xFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 }
1967
1968 cifs_buf_release(pSMB);
1969
Steve French50c2f752007-07-13 00:33:32 +00001970 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 since file handle passed in no longer valid */
1972
1973 return rc;
1974}
1975
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001976void
1977cifs_writedata_release(struct kref *refcount)
1978{
1979 struct cifs_writedata *wdata = container_of(refcount,
1980 struct cifs_writedata, refcount);
1981
1982 if (wdata->cfile)
1983 cifsFileInfo_put(wdata->cfile);
1984
1985 kfree(wdata);
1986}
1987
1988/*
1989 * Write failed with a retryable error. Resend the write request. It's also
1990 * possible that the page was redirtied so re-clean the page.
1991 */
1992static void
1993cifs_writev_requeue(struct cifs_writedata *wdata)
1994{
1995 int i, rc;
1996 struct inode *inode = wdata->cfile->dentry->d_inode;
1997
1998 for (i = 0; i < wdata->nr_pages; i++) {
1999 lock_page(wdata->pages[i]);
2000 clear_page_dirty_for_io(wdata->pages[i]);
2001 }
2002
2003 do {
2004 rc = cifs_async_writev(wdata);
2005 } while (rc == -EAGAIN);
2006
2007 for (i = 0; i < wdata->nr_pages; i++) {
2008 if (rc != 0)
2009 SetPageError(wdata->pages[i]);
2010 unlock_page(wdata->pages[i]);
2011 }
2012
2013 mapping_set_error(inode->i_mapping, rc);
2014 kref_put(&wdata->refcount, cifs_writedata_release);
2015}
2016
2017static void
2018cifs_writev_complete(struct work_struct *work)
2019{
2020 struct cifs_writedata *wdata = container_of(work,
2021 struct cifs_writedata, work);
2022 struct inode *inode = wdata->cfile->dentry->d_inode;
2023 int i = 0;
2024
2025 if (wdata->result == 0) {
2026 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2027 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2028 wdata->bytes);
2029 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2030 return cifs_writev_requeue(wdata);
2031
2032 for (i = 0; i < wdata->nr_pages; i++) {
2033 struct page *page = wdata->pages[i];
2034 if (wdata->result == -EAGAIN)
2035 __set_page_dirty_nobuffers(page);
2036 else if (wdata->result < 0)
2037 SetPageError(page);
2038 end_page_writeback(page);
2039 page_cache_release(page);
2040 }
2041 if (wdata->result != -EAGAIN)
2042 mapping_set_error(inode->i_mapping, wdata->result);
2043 kref_put(&wdata->refcount, cifs_writedata_release);
2044}
2045
2046struct cifs_writedata *
2047cifs_writedata_alloc(unsigned int nr_pages)
2048{
2049 struct cifs_writedata *wdata;
2050
2051 /* this would overflow */
2052 if (nr_pages == 0) {
2053 cERROR(1, "%s: called with nr_pages == 0!", __func__);
2054 return NULL;
2055 }
2056
2057 /* writedata + number of page pointers */
2058 wdata = kzalloc(sizeof(*wdata) +
2059 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
2060 if (wdata != NULL) {
2061 INIT_WORK(&wdata->work, cifs_writev_complete);
2062 kref_init(&wdata->refcount);
2063 }
2064 return wdata;
2065}
2066
2067/*
2068 * Check the midState and signature on received buffer (if any), and queue the
2069 * workqueue completion task.
2070 */
2071static void
2072cifs_writev_callback(struct mid_q_entry *mid)
2073{
2074 struct cifs_writedata *wdata = mid->callback_data;
Steve French96daf2b2011-05-27 04:34:02 +00002075 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002076 unsigned int written;
2077 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2078
2079 switch (mid->midState) {
2080 case MID_RESPONSE_RECEIVED:
2081 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2082 if (wdata->result != 0)
2083 break;
2084
2085 written = le16_to_cpu(smb->CountHigh);
2086 written <<= 16;
2087 written += le16_to_cpu(smb->Count);
2088 /*
2089 * Mask off high 16 bits when bytes written as returned
2090 * by the server is greater than bytes requested by the
2091 * client. OS/2 servers are known to set incorrect
2092 * CountHigh values.
2093 */
2094 if (written > wdata->bytes)
2095 written &= 0xFFFF;
2096
2097 if (written < wdata->bytes)
2098 wdata->result = -ENOSPC;
2099 else
2100 wdata->bytes = written;
2101 break;
2102 case MID_REQUEST_SUBMITTED:
2103 case MID_RETRY_NEEDED:
2104 wdata->result = -EAGAIN;
2105 break;
2106 default:
2107 wdata->result = -EIO;
2108 break;
2109 }
2110
2111 queue_work(system_nrt_wq, &wdata->work);
2112 DeleteMidQEntry(mid);
2113 atomic_dec(&tcon->ses->server->inFlight);
2114 wake_up(&tcon->ses->server->request_q);
2115}
2116
2117/* cifs_async_writev - send an async write, and set up mid to handle result */
2118int
2119cifs_async_writev(struct cifs_writedata *wdata)
2120{
2121 int i, rc = -EACCES;
2122 WRITE_REQ *smb = NULL;
2123 int wct;
Steve French96daf2b2011-05-27 04:34:02 +00002124 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002125 struct inode *inode = wdata->cfile->dentry->d_inode;
2126 struct kvec *iov = NULL;
2127
2128 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2129 wct = 14;
2130 } else {
2131 wct = 12;
2132 if (wdata->offset >> 32 > 0) {
2133 /* can not handle big offset for old srv */
2134 return -EIO;
2135 }
2136 }
2137
2138 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2139 if (rc)
2140 goto async_writev_out;
2141
2142 /* 1 iov per page + 1 for header */
2143 iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
2144 if (iov == NULL) {
2145 rc = -ENOMEM;
2146 goto async_writev_out;
2147 }
2148
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002149 smb->hdr.Pid = cpu_to_le16((__u16)wdata->cfile->pid);
2150 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->cfile->pid >> 16));
2151
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002152 smb->AndXCommand = 0xFF; /* none */
2153 smb->Fid = wdata->cfile->netfid;
2154 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2155 if (wct == 14)
2156 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2157 smb->Reserved = 0xFFFFFFFF;
2158 smb->WriteMode = 0;
2159 smb->Remaining = 0;
2160
2161 smb->DataOffset =
2162 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2163
2164 /* 4 for RFC1001 length + 1 for BCC */
2165 iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2166 iov[0].iov_base = smb;
2167
2168 /* marshal up the pages into iov array */
2169 wdata->bytes = 0;
2170 for (i = 0; i < wdata->nr_pages; i++) {
2171 iov[i + 1].iov_len = min(inode->i_size -
2172 page_offset(wdata->pages[i]),
2173 (loff_t)PAGE_CACHE_SIZE);
2174 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2175 wdata->bytes += iov[i + 1].iov_len;
2176 }
2177
2178 cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
2179
2180 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2181 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2182
2183 if (wct == 14) {
2184 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2185 put_bcc(wdata->bytes + 1, &smb->hdr);
2186 } else {
2187 /* wct == 12 */
2188 struct smb_com_writex_req *smbw =
2189 (struct smb_com_writex_req *)smb;
2190 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2191 put_bcc(wdata->bytes + 5, &smbw->hdr);
2192 iov[0].iov_len += 4; /* pad bigger by four bytes */
2193 }
2194
2195 kref_get(&wdata->refcount);
2196 rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
Jeff Layton44d22d82011-10-19 15:29:49 -04002197 NULL, cifs_writev_callback, wdata, false);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002198
2199 if (rc == 0)
2200 cifs_stats_inc(&tcon->num_writes);
2201 else
2202 kref_put(&wdata->refcount, cifs_writedata_release);
2203
2204 /* send is done, unmap pages */
2205 for (i = 0; i < wdata->nr_pages; i++)
2206 kunmap(wdata->pages[i]);
2207
2208async_writev_out:
2209 cifs_small_buf_release(smb);
2210 kfree(iov);
2211 return rc;
2212}
2213
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002214int
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002215CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
2216 unsigned int *nbytes, struct kvec *iov, int n_vec,
2217 const int long_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218{
2219 int rc = -EACCES;
2220 WRITE_REQ *pSMB = NULL;
Steve Frenchec637e32005-12-12 20:53:18 -08002221 int wct;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002222 int smb_hdr_len;
Steve Frenchec637e32005-12-12 20:53:18 -08002223 int resp_buf_type = 0;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002224 __u32 pid = io_parms->pid;
2225 __u16 netfid = io_parms->netfid;
2226 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00002227 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002228 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002230 *nbytes = 0;
2231
Joe Perchesb6b38f72010-04-21 03:50:45 +00002232 cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
Steve Frenchff7feac2005-11-15 16:45:16 -08002233
Steve French4c3130e2008-12-09 00:28:16 +00002234 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
Steve French8cc64c62005-10-03 13:49:43 -07002235 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00002236 } else {
Steve French8cc64c62005-10-03 13:49:43 -07002237 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00002238 if ((offset >> 32) > 0) {
2239 /* can not handle big offset for old srv */
2240 return -EIO;
2241 }
2242 }
Steve French8cc64c62005-10-03 13:49:43 -07002243 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 if (rc)
2245 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002246
2247 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2248 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2249
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 /* tcon and ses pointer are checked in smb_init */
2251 if (tcon->ses->server == NULL)
2252 return -ECONNABORTED;
2253
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002254 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 pSMB->Fid = netfid;
2256 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00002257 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002258 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 pSMB->Reserved = 0xFFFFFFFF;
2260 pSMB->WriteMode = 0;
2261 pSMB->Remaining = 0;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002262
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00002264 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265
Steve French3e844692005-10-03 13:37:24 -07002266 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2267 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002268 /* header + 1 byte pad */
2269 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
Steve French790fe572007-07-07 19:25:05 +00002270 if (wct == 14)
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002271 inc_rfc1001_len(pSMB, count + 1);
Steve French8cc64c62005-10-03 13:49:43 -07002272 else /* wct == 12 */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002273 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
Steve French790fe572007-07-07 19:25:05 +00002274 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002275 pSMB->ByteCount = cpu_to_le16(count + 1);
2276 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
Steve French50c2f752007-07-13 00:33:32 +00002277 struct smb_com_writex_req *pSMBW =
Steve French8cc64c62005-10-03 13:49:43 -07002278 (struct smb_com_writex_req *)pSMB;
2279 pSMBW->ByteCount = cpu_to_le16(count + 5);
2280 }
Steve French3e844692005-10-03 13:37:24 -07002281 iov[0].iov_base = pSMB;
Steve French790fe572007-07-07 19:25:05 +00002282 if (wct == 14)
Steve Frenchec637e32005-12-12 20:53:18 -08002283 iov[0].iov_len = smb_hdr_len + 4;
2284 else /* wct == 12 pad bigger by four bytes */
2285 iov[0].iov_len = smb_hdr_len + 8;
Steve French50c2f752007-07-13 00:33:32 +00002286
Steve French3e844692005-10-03 13:37:24 -07002287
Steve Frenchec637e32005-12-12 20:53:18 -08002288 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
Steve French133672e2007-11-13 22:41:37 +00002289 long_op);
Steve Frencha4544342005-08-24 13:59:35 -07002290 cifs_stats_inc(&tcon->num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002292 cFYI(1, "Send error Write2 = %d", rc);
Steve French790fe572007-07-07 19:25:05 +00002293 } else if (resp_buf_type == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -08002294 /* presumably this can not happen, but best to be safe */
2295 rc = -EIO;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002296 } else {
Steve Frenchad7a2922008-02-07 23:25:02 +00002297 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002298 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2299 *nbytes = (*nbytes) << 16;
2300 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05302301
2302 /*
2303 * Mask off high 16 bits when bytes written as returned by the
2304 * server is greater than bytes requested by the client. OS/2
2305 * servers are known to set incorrect CountHigh values.
2306 */
2307 if (*nbytes > count)
2308 *nbytes &= 0xFFFF;
Steve French50c2f752007-07-13 00:33:32 +00002309 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310
Steve French4b8f9302006-02-26 16:41:18 +00002311/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00002312 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002313 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00002314 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002315 cifs_buf_release(iov[0].iov_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316
Steve French50c2f752007-07-13 00:33:32 +00002317 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 since file handle passed in no longer valid */
2319
2320 return rc;
2321}
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002322
2323
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324int
Steve French96daf2b2011-05-27 04:34:02 +00002325CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002326 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 const __u64 offset, const __u32 numUnlock,
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002328 const __u32 numLock, const __u8 lockType,
2329 const bool waitFlag, const __u8 oplock_level)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330{
2331 int rc = 0;
2332 LOCK_REQ *pSMB = NULL;
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002333/* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 int bytes_returned;
2335 int timeout = 0;
2336 __u16 count;
2337
Joe Perchesb6b38f72010-04-21 03:50:45 +00002338 cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
Steve French46810cb2005-04-28 22:41:09 -07002339 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2340
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341 if (rc)
2342 return rc;
2343
Steve French790fe572007-07-07 19:25:05 +00002344 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
Steve French133672e2007-11-13 22:41:37 +00002345 timeout = CIFS_ASYNC_OP; /* no response expected */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 pSMB->Timeout = 0;
Steve French4b18f2a2008-04-29 00:06:05 +00002347 } else if (waitFlag) {
Steve French133672e2007-11-13 22:41:37 +00002348 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2350 } else {
2351 pSMB->Timeout = 0;
2352 }
2353
2354 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2355 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2356 pSMB->LockType = lockType;
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002357 pSMB->OplockLevel = oplock_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 pSMB->AndXCommand = 0xFF; /* none */
2359 pSMB->Fid = smb_file_id; /* netfid stays le */
2360
Steve French790fe572007-07-07 19:25:05 +00002361 if ((numLock != 0) || (numUnlock != 0)) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002362 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 /* BB where to store pid high? */
2364 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2365 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2366 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2367 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2368 count = sizeof(LOCKING_ANDX_RANGE);
2369 } else {
2370 /* oplock break */
2371 count = 0;
2372 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002373 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 pSMB->ByteCount = cpu_to_le16(count);
2375
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002376 if (waitFlag) {
2377 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002378 (struct smb_hdr *) pSMB, &bytes_returned);
Steve French133672e2007-11-13 22:41:37 +00002379 cifs_small_buf_release(pSMB);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002380 } else {
Steve French133672e2007-11-13 22:41:37 +00002381 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
2382 timeout);
2383 /* SMB buffer freed by function above */
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002384 }
Steve Frencha4544342005-08-24 13:59:35 -07002385 cifs_stats_inc(&tcon->num_locks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002386 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002387 cFYI(1, "Send error in Lock = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388
Steve French50c2f752007-07-13 00:33:32 +00002389 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 since file handle passed in no longer valid */
2391 return rc;
2392}
2393
2394int
Steve French96daf2b2011-05-27 04:34:02 +00002395CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
Steve French08547b02006-02-28 22:39:25 +00002396 const __u16 smb_file_id, const int get_flag, const __u64 len,
Steve French50c2f752007-07-13 00:33:32 +00002397 struct file_lock *pLockData, const __u16 lock_type,
Steve French4b18f2a2008-04-29 00:06:05 +00002398 const bool waitFlag)
Steve French08547b02006-02-28 22:39:25 +00002399{
2400 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2401 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French08547b02006-02-28 22:39:25 +00002402 struct cifs_posix_lock *parm_data;
2403 int rc = 0;
Steve French3a5ff612006-07-14 22:37:11 +00002404 int timeout = 0;
Steve French08547b02006-02-28 22:39:25 +00002405 int bytes_returned = 0;
Steve French133672e2007-11-13 22:41:37 +00002406 int resp_buf_type = 0;
Steve French08547b02006-02-28 22:39:25 +00002407 __u16 params, param_offset, offset, byte_count, count;
Steve French133672e2007-11-13 22:41:37 +00002408 struct kvec iov[1];
Steve French08547b02006-02-28 22:39:25 +00002409
Joe Perchesb6b38f72010-04-21 03:50:45 +00002410 cFYI(1, "Posix Lock");
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002411
Steve French790fe572007-07-07 19:25:05 +00002412 if (pLockData == NULL)
Marcin Slusarzed5f0372008-05-13 04:01:01 +00002413 return -EINVAL;
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002414
Steve French08547b02006-02-28 22:39:25 +00002415 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2416
2417 if (rc)
2418 return rc;
2419
2420 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2421
Steve French50c2f752007-07-13 00:33:32 +00002422 params = 6;
Steve French08547b02006-02-28 22:39:25 +00002423 pSMB->MaxSetupCount = 0;
2424 pSMB->Reserved = 0;
2425 pSMB->Flags = 0;
Steve French08547b02006-02-28 22:39:25 +00002426 pSMB->Reserved2 = 0;
2427 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2428 offset = param_offset + params;
2429
Steve French08547b02006-02-28 22:39:25 +00002430 count = sizeof(struct cifs_posix_lock);
2431 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002432 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Steve French08547b02006-02-28 22:39:25 +00002433 pSMB->SetupCount = 1;
2434 pSMB->Reserved3 = 0;
Steve French790fe572007-07-07 19:25:05 +00002435 if (get_flag)
Steve French08547b02006-02-28 22:39:25 +00002436 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2437 else
2438 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2439 byte_count = 3 /* pad */ + params + count;
2440 pSMB->DataCount = cpu_to_le16(count);
2441 pSMB->ParameterCount = cpu_to_le16(params);
2442 pSMB->TotalDataCount = pSMB->DataCount;
2443 pSMB->TotalParameterCount = pSMB->ParameterCount;
2444 pSMB->ParameterOffset = cpu_to_le16(param_offset);
Steve French50c2f752007-07-13 00:33:32 +00002445 parm_data = (struct cifs_posix_lock *)
Steve French08547b02006-02-28 22:39:25 +00002446 (((char *) &pSMB->hdr.Protocol) + offset);
2447
2448 parm_data->lock_type = cpu_to_le16(lock_type);
Steve French790fe572007-07-07 19:25:05 +00002449 if (waitFlag) {
Steve French133672e2007-11-13 22:41:37 +00002450 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Steve Frenchcec6815a2006-05-30 18:07:17 +00002451 parm_data->lock_flags = cpu_to_le16(1);
Steve French3a5ff612006-07-14 22:37:11 +00002452 pSMB->Timeout = cpu_to_le32(-1);
2453 } else
2454 pSMB->Timeout = 0;
2455
Steve French08547b02006-02-28 22:39:25 +00002456 parm_data->pid = cpu_to_le32(current->tgid);
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002457 parm_data->start = cpu_to_le64(pLockData->fl_start);
Steve Frenchcec6815a2006-05-30 18:07:17 +00002458 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
Steve French08547b02006-02-28 22:39:25 +00002459
2460 pSMB->DataOffset = cpu_to_le16(offset);
Steve Frenchf26282c2006-03-01 09:17:37 +00002461 pSMB->Fid = smb_file_id;
Steve French08547b02006-02-28 22:39:25 +00002462 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2463 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002464 inc_rfc1001_len(pSMB, byte_count);
Steve French08547b02006-02-28 22:39:25 +00002465 pSMB->ByteCount = cpu_to_le16(byte_count);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002466 if (waitFlag) {
2467 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2468 (struct smb_hdr *) pSMBr, &bytes_returned);
2469 } else {
Steve French133672e2007-11-13 22:41:37 +00002470 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002471 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French133672e2007-11-13 22:41:37 +00002472 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2473 &resp_buf_type, timeout);
2474 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2475 not try to free it twice below on exit */
2476 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002477 }
2478
Steve French08547b02006-02-28 22:39:25 +00002479 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002480 cFYI(1, "Send error in Posix Lock = %d", rc);
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002481 } else if (get_flag) {
2482 /* lock structure can be returned on get */
2483 __u16 data_offset;
2484 __u16 data_count;
2485 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French08547b02006-02-28 22:39:25 +00002486
Jeff Layton820a8032011-05-04 08:05:26 -04002487 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002488 rc = -EIO; /* bad smb */
2489 goto plk_err_exit;
2490 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002491 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2492 data_count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French790fe572007-07-07 19:25:05 +00002493 if (data_count < sizeof(struct cifs_posix_lock)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002494 rc = -EIO;
2495 goto plk_err_exit;
2496 }
2497 parm_data = (struct cifs_posix_lock *)
2498 ((char *)&pSMBr->hdr.Protocol + data_offset);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002499 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002500 pLockData->fl_type = F_UNLCK;
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002501 else {
2502 if (parm_data->lock_type ==
2503 __constant_cpu_to_le16(CIFS_RDLCK))
2504 pLockData->fl_type = F_RDLCK;
2505 else if (parm_data->lock_type ==
2506 __constant_cpu_to_le16(CIFS_WRLCK))
2507 pLockData->fl_type = F_WRLCK;
2508
Steve French5443d132011-03-13 05:08:25 +00002509 pLockData->fl_start = le64_to_cpu(parm_data->start);
2510 pLockData->fl_end = pLockData->fl_start +
2511 le64_to_cpu(parm_data->length) - 1;
2512 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002513 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002514 }
Steve French50c2f752007-07-13 00:33:32 +00002515
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002516plk_err_exit:
Steve French08547b02006-02-28 22:39:25 +00002517 if (pSMB)
2518 cifs_small_buf_release(pSMB);
2519
Steve French133672e2007-11-13 22:41:37 +00002520 if (resp_buf_type == CIFS_SMALL_BUFFER)
2521 cifs_small_buf_release(iov[0].iov_base);
2522 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2523 cifs_buf_release(iov[0].iov_base);
2524
Steve French08547b02006-02-28 22:39:25 +00002525 /* Note: On -EAGAIN error only caller can retry on handle based calls
2526 since file handle passed in no longer valid */
2527
2528 return rc;
2529}
2530
2531
2532int
Steve French96daf2b2011-05-27 04:34:02 +00002533CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534{
2535 int rc = 0;
2536 CLOSE_REQ *pSMB = NULL;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002537 cFYI(1, "In CIFSSMBClose");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538
2539/* do not retry on dead session on close */
2540 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
Steve French790fe572007-07-07 19:25:05 +00002541 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 return 0;
2543 if (rc)
2544 return rc;
2545
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 pSMB->FileID = (__u16) smb_file_id;
Steve Frenchb815f1e2006-10-02 05:53:29 +00002547 pSMB->LastWriteTime = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 pSMB->ByteCount = 0;
Steve French133672e2007-11-13 22:41:37 +00002549 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002550 cifs_stats_inc(&tcon->num_closes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 if (rc) {
Steve French790fe572007-07-07 19:25:05 +00002552 if (rc != -EINTR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 /* EINTR is expected when user ctl-c to kill app */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002554 cERROR(1, "Send error in Close = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 }
2556 }
2557
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 /* Since session is dead, file will be closed on server already */
Steve French790fe572007-07-07 19:25:05 +00002559 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 rc = 0;
2561
2562 return rc;
2563}
2564
2565int
Steve French96daf2b2011-05-27 04:34:02 +00002566CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
Steve Frenchb298f222009-02-21 21:17:43 +00002567{
2568 int rc = 0;
2569 FLUSH_REQ *pSMB = NULL;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002570 cFYI(1, "In CIFSSMBFlush");
Steve Frenchb298f222009-02-21 21:17:43 +00002571
2572 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2573 if (rc)
2574 return rc;
2575
2576 pSMB->FileID = (__u16) smb_file_id;
2577 pSMB->ByteCount = 0;
2578 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
2579 cifs_stats_inc(&tcon->num_flushes);
2580 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002581 cERROR(1, "Send error in Flush = %d", rc);
Steve Frenchb298f222009-02-21 21:17:43 +00002582
2583 return rc;
2584}
2585
2586int
Steve French96daf2b2011-05-27 04:34:02 +00002587CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002589 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590{
2591 int rc = 0;
2592 RENAME_REQ *pSMB = NULL;
2593 RENAME_RSP *pSMBr = NULL;
2594 int bytes_returned;
2595 int name_len, name_len2;
2596 __u16 count;
2597
Joe Perchesb6b38f72010-04-21 03:50:45 +00002598 cFYI(1, "In CIFSSMBRename");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599renameRetry:
2600 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2601 (void **) &pSMBr);
2602 if (rc)
2603 return rc;
2604
2605 pSMB->BufferFormat = 0x04;
2606 pSMB->SearchAttributes =
2607 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2608 ATTR_DIRECTORY);
2609
2610 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2611 name_len =
Steve French50c2f752007-07-13 00:33:32 +00002612 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
Steve French737b7582005-04-28 22:41:06 -07002613 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 name_len++; /* trailing null */
2615 name_len *= 2;
2616 pSMB->OldFileName[name_len] = 0x04; /* pad */
2617 /* protocol requires ASCII signature byte on Unicode string */
2618 pSMB->OldFileName[name_len + 1] = 0x00;
2619 name_len2 =
Steve French582d21e2008-05-13 04:54:12 +00002620 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
Steve French737b7582005-04-28 22:41:06 -07002621 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2623 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002624 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 name_len = strnlen(fromName, PATH_MAX);
2626 name_len++; /* trailing null */
2627 strncpy(pSMB->OldFileName, fromName, name_len);
2628 name_len2 = strnlen(toName, PATH_MAX);
2629 name_len2++; /* trailing null */
2630 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2631 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2632 name_len2++; /* trailing null */
2633 name_len2++; /* signature byte */
2634 }
2635
2636 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002637 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 pSMB->ByteCount = cpu_to_le16(count);
2639
2640 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2641 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002642 cifs_stats_inc(&tcon->num_renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002643 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002644 cFYI(1, "Send error in rename = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 cifs_buf_release(pSMB);
2647
2648 if (rc == -EAGAIN)
2649 goto renameRetry;
2650
2651 return rc;
2652}
2653
Steve French96daf2b2011-05-27 04:34:02 +00002654int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
Jeff Layton391e5752008-09-24 11:32:59 -04002655 int netfid, const char *target_name,
Steve French50c2f752007-07-13 00:33:32 +00002656 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657{
2658 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2659 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French50c2f752007-07-13 00:33:32 +00002660 struct set_file_rename *rename_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 char *data_offset;
2662 char dummy_string[30];
2663 int rc = 0;
2664 int bytes_returned = 0;
2665 int len_of_str;
2666 __u16 params, param_offset, offset, count, byte_count;
2667
Joe Perchesb6b38f72010-04-21 03:50:45 +00002668 cFYI(1, "Rename to File by handle");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2670 (void **) &pSMBr);
2671 if (rc)
2672 return rc;
2673
2674 params = 6;
2675 pSMB->MaxSetupCount = 0;
2676 pSMB->Reserved = 0;
2677 pSMB->Flags = 0;
2678 pSMB->Timeout = 0;
2679 pSMB->Reserved2 = 0;
2680 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2681 offset = param_offset + params;
2682
2683 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2684 rename_info = (struct set_file_rename *) data_offset;
2685 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002686 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687 pSMB->SetupCount = 1;
2688 pSMB->Reserved3 = 0;
2689 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2690 byte_count = 3 /* pad */ + params;
2691 pSMB->ParameterCount = cpu_to_le16(params);
2692 pSMB->TotalParameterCount = pSMB->ParameterCount;
2693 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2694 pSMB->DataOffset = cpu_to_le16(offset);
2695 /* construct random name ".cifs_tmp<inodenum><mid>" */
2696 rename_info->overwrite = cpu_to_le32(1);
2697 rename_info->root_fid = 0;
2698 /* unicode only call */
Steve French790fe572007-07-07 19:25:05 +00002699 if (target_name == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002700 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2701 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
Steve French737b7582005-04-28 22:41:06 -07002702 dummy_string, 24, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 } else {
Steve Frenchb1a45692005-05-17 16:07:23 -05002704 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
Steve French50c2f752007-07-13 00:33:32 +00002705 target_name, PATH_MAX, nls_codepage,
2706 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 }
2708 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
Jeff Layton391e5752008-09-24 11:32:59 -04002709 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002710 byte_count += count;
2711 pSMB->DataCount = cpu_to_le16(count);
2712 pSMB->TotalDataCount = pSMB->DataCount;
2713 pSMB->Fid = netfid;
2714 pSMB->InformationLevel =
2715 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2716 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002717 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 pSMB->ByteCount = cpu_to_le16(byte_count);
2719 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00002720 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002721 cifs_stats_inc(&pTcon->num_t2renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002722 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002723 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
Steve Frencha5a2b482005-08-20 21:42:53 -07002724
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 cifs_buf_release(pSMB);
2726
2727 /* Note: On -EAGAIN error only caller can retry on handle based calls
2728 since file handle passed in no longer valid */
2729
2730 return rc;
2731}
2732
2733int
Steve French96daf2b2011-05-27 04:34:02 +00002734CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
Steve French50c2f752007-07-13 00:33:32 +00002735 const __u16 target_tid, const char *toName, const int flags,
2736 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737{
2738 int rc = 0;
2739 COPY_REQ *pSMB = NULL;
2740 COPY_RSP *pSMBr = NULL;
2741 int bytes_returned;
2742 int name_len, name_len2;
2743 __u16 count;
2744
Joe Perchesb6b38f72010-04-21 03:50:45 +00002745 cFYI(1, "In CIFSSMBCopy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746copyRetry:
2747 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2748 (void **) &pSMBr);
2749 if (rc)
2750 return rc;
2751
2752 pSMB->BufferFormat = 0x04;
2753 pSMB->Tid2 = target_tid;
2754
2755 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2756
2757 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve French50c2f752007-07-13 00:33:32 +00002758 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
Steve French737b7582005-04-28 22:41:06 -07002759 fromName, PATH_MAX, nls_codepage,
2760 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002761 name_len++; /* trailing null */
2762 name_len *= 2;
2763 pSMB->OldFileName[name_len] = 0x04; /* pad */
2764 /* protocol requires ASCII signature byte on Unicode string */
2765 pSMB->OldFileName[name_len + 1] = 0x00;
Steve French50c2f752007-07-13 00:33:32 +00002766 name_len2 =
2767 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
Steve French737b7582005-04-28 22:41:06 -07002768 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2770 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002771 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 name_len = strnlen(fromName, PATH_MAX);
2773 name_len++; /* trailing null */
2774 strncpy(pSMB->OldFileName, fromName, name_len);
2775 name_len2 = strnlen(toName, PATH_MAX);
2776 name_len2++; /* trailing null */
2777 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2778 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2779 name_len2++; /* trailing null */
2780 name_len2++; /* signature byte */
2781 }
2782
2783 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002784 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 pSMB->ByteCount = cpu_to_le16(count);
2786
2787 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2788 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2789 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002790 cFYI(1, "Send error in copy = %d with %d files copied",
2791 rc, le16_to_cpu(pSMBr->CopyCount));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 }
Steve French0d817bc2008-05-22 02:02:03 +00002793 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
2795 if (rc == -EAGAIN)
2796 goto copyRetry;
2797
2798 return rc;
2799}
2800
2801int
Steve French96daf2b2011-05-27 04:34:02 +00002802CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803 const char *fromName, const char *toName,
2804 const struct nls_table *nls_codepage)
2805{
2806 TRANSACTION2_SPI_REQ *pSMB = NULL;
2807 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2808 char *data_offset;
2809 int name_len;
2810 int name_len_target;
2811 int rc = 0;
2812 int bytes_returned = 0;
2813 __u16 params, param_offset, offset, byte_count;
2814
Joe Perchesb6b38f72010-04-21 03:50:45 +00002815 cFYI(1, "In Symlink Unix style");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816createSymLinkRetry:
2817 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2818 (void **) &pSMBr);
2819 if (rc)
2820 return rc;
2821
2822 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2823 name_len =
Steve Frenche89dc922005-11-11 15:18:19 -08002824 cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 /* find define for this maxpathcomponent */
2826 , nls_codepage);
2827 name_len++; /* trailing null */
2828 name_len *= 2;
2829
Steve French50c2f752007-07-13 00:33:32 +00002830 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831 name_len = strnlen(fromName, PATH_MAX);
2832 name_len++; /* trailing null */
2833 strncpy(pSMB->FileName, fromName, name_len);
2834 }
2835 params = 6 + name_len;
2836 pSMB->MaxSetupCount = 0;
2837 pSMB->Reserved = 0;
2838 pSMB->Flags = 0;
2839 pSMB->Timeout = 0;
2840 pSMB->Reserved2 = 0;
2841 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002842 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843 offset = param_offset + params;
2844
2845 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2846 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2847 name_len_target =
Steve Frenche89dc922005-11-11 15:18:19 -08002848 cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 /* find define for this maxpathcomponent */
2850 , nls_codepage);
2851 name_len_target++; /* trailing null */
2852 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00002853 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 name_len_target = strnlen(toName, PATH_MAX);
2855 name_len_target++; /* trailing null */
2856 strncpy(data_offset, toName, name_len_target);
2857 }
2858
2859 pSMB->MaxParameterCount = cpu_to_le16(2);
2860 /* BB find exact max on data count below from sess */
2861 pSMB->MaxDataCount = cpu_to_le16(1000);
2862 pSMB->SetupCount = 1;
2863 pSMB->Reserved3 = 0;
2864 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2865 byte_count = 3 /* pad */ + params + name_len_target;
2866 pSMB->DataCount = cpu_to_le16(name_len_target);
2867 pSMB->ParameterCount = cpu_to_le16(params);
2868 pSMB->TotalDataCount = pSMB->DataCount;
2869 pSMB->TotalParameterCount = pSMB->ParameterCount;
2870 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2871 pSMB->DataOffset = cpu_to_le16(offset);
2872 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2873 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002874 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 pSMB->ByteCount = cpu_to_le16(byte_count);
2876 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2877 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002878 cifs_stats_inc(&tcon->num_symlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002879 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002880 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
Steve French0d817bc2008-05-22 02:02:03 +00002882 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883
2884 if (rc == -EAGAIN)
2885 goto createSymLinkRetry;
2886
2887 return rc;
2888}
2889
2890int
Steve French96daf2b2011-05-27 04:34:02 +00002891CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002893 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894{
2895 TRANSACTION2_SPI_REQ *pSMB = NULL;
2896 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2897 char *data_offset;
2898 int name_len;
2899 int name_len_target;
2900 int rc = 0;
2901 int bytes_returned = 0;
2902 __u16 params, param_offset, offset, byte_count;
2903
Joe Perchesb6b38f72010-04-21 03:50:45 +00002904 cFYI(1, "In Create Hard link Unix style");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905createHardLinkRetry:
2906 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2907 (void **) &pSMBr);
2908 if (rc)
2909 return rc;
2910
2911 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchb1a45692005-05-17 16:07:23 -05002912 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
Steve French737b7582005-04-28 22:41:06 -07002913 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 name_len++; /* trailing null */
2915 name_len *= 2;
2916
Steve French50c2f752007-07-13 00:33:32 +00002917 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 name_len = strnlen(toName, PATH_MAX);
2919 name_len++; /* trailing null */
2920 strncpy(pSMB->FileName, toName, name_len);
2921 }
2922 params = 6 + name_len;
2923 pSMB->MaxSetupCount = 0;
2924 pSMB->Reserved = 0;
2925 pSMB->Flags = 0;
2926 pSMB->Timeout = 0;
2927 pSMB->Reserved2 = 0;
2928 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002929 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930 offset = param_offset + params;
2931
2932 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2933 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2934 name_len_target =
Steve Frenchb1a45692005-05-17 16:07:23 -05002935 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
Steve French737b7582005-04-28 22:41:06 -07002936 nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 name_len_target++; /* trailing null */
2938 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00002939 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 name_len_target = strnlen(fromName, PATH_MAX);
2941 name_len_target++; /* trailing null */
2942 strncpy(data_offset, fromName, name_len_target);
2943 }
2944
2945 pSMB->MaxParameterCount = cpu_to_le16(2);
2946 /* BB find exact max on data count below from sess*/
2947 pSMB->MaxDataCount = cpu_to_le16(1000);
2948 pSMB->SetupCount = 1;
2949 pSMB->Reserved3 = 0;
2950 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2951 byte_count = 3 /* pad */ + params + name_len_target;
2952 pSMB->ParameterCount = cpu_to_le16(params);
2953 pSMB->TotalParameterCount = pSMB->ParameterCount;
2954 pSMB->DataCount = cpu_to_le16(name_len_target);
2955 pSMB->TotalDataCount = pSMB->DataCount;
2956 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2957 pSMB->DataOffset = cpu_to_le16(offset);
2958 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2959 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002960 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 pSMB->ByteCount = cpu_to_le16(byte_count);
2962 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2963 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002964 cifs_stats_inc(&tcon->num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002965 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002966 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002967
2968 cifs_buf_release(pSMB);
2969 if (rc == -EAGAIN)
2970 goto createHardLinkRetry;
2971
2972 return rc;
2973}
2974
2975int
Steve French96daf2b2011-05-27 04:34:02 +00002976CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002978 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979{
2980 int rc = 0;
2981 NT_RENAME_REQ *pSMB = NULL;
2982 RENAME_RSP *pSMBr = NULL;
2983 int bytes_returned;
2984 int name_len, name_len2;
2985 __u16 count;
2986
Joe Perchesb6b38f72010-04-21 03:50:45 +00002987 cFYI(1, "In CIFSCreateHardLink");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988winCreateHardLinkRetry:
2989
2990 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2991 (void **) &pSMBr);
2992 if (rc)
2993 return rc;
2994
2995 pSMB->SearchAttributes =
2996 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2997 ATTR_DIRECTORY);
2998 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2999 pSMB->ClusterCount = 0;
3000
3001 pSMB->BufferFormat = 0x04;
3002
3003 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3004 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05003005 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
Steve French737b7582005-04-28 22:41:06 -07003006 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 name_len++; /* trailing null */
3008 name_len *= 2;
Jeff Laytonfcc7c092009-02-28 12:59:03 -05003009
3010 /* protocol specifies ASCII buffer format (0x04) for unicode */
3011 pSMB->OldFileName[name_len] = 0x04;
3012 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013 name_len2 =
Steve French50c2f752007-07-13 00:33:32 +00003014 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
Steve French737b7582005-04-28 22:41:06 -07003015 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3017 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00003018 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 name_len = strnlen(fromName, PATH_MAX);
3020 name_len++; /* trailing null */
3021 strncpy(pSMB->OldFileName, fromName, name_len);
3022 name_len2 = strnlen(toName, PATH_MAX);
3023 name_len2++; /* trailing null */
3024 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3025 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
3026 name_len2++; /* trailing null */
3027 name_len2++; /* signature byte */
3028 }
3029
3030 count = 1 /* string type byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003031 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 pSMB->ByteCount = cpu_to_le16(count);
3033
3034 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3035 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07003036 cifs_stats_inc(&tcon->num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00003037 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003038 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00003039
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 cifs_buf_release(pSMB);
3041 if (rc == -EAGAIN)
3042 goto winCreateHardLinkRetry;
3043
3044 return rc;
3045}
3046
3047int
Steve French96daf2b2011-05-27 04:34:02 +00003048CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
Jeff Layton460b9692009-04-30 07:17:56 -04003049 const unsigned char *searchName, char **symlinkinfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003050 const struct nls_table *nls_codepage)
3051{
3052/* SMB_QUERY_FILE_UNIX_LINK */
3053 TRANSACTION2_QPI_REQ *pSMB = NULL;
3054 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3055 int rc = 0;
3056 int bytes_returned;
3057 int name_len;
3058 __u16 params, byte_count;
Jeff Layton460b9692009-04-30 07:17:56 -04003059 char *data_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060
Joe Perchesb6b38f72010-04-21 03:50:45 +00003061 cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062
3063querySymLinkRetry:
3064 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3065 (void **) &pSMBr);
3066 if (rc)
3067 return rc;
3068
3069 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3070 name_len =
Steve French50c2f752007-07-13 00:33:32 +00003071 cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
3072 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003073 name_len++; /* trailing null */
3074 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003075 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 name_len = strnlen(searchName, PATH_MAX);
3077 name_len++; /* trailing null */
3078 strncpy(pSMB->FileName, searchName, name_len);
3079 }
3080
3081 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3082 pSMB->TotalDataCount = 0;
3083 pSMB->MaxParameterCount = cpu_to_le16(2);
Jeff Layton46a75742009-05-24 18:45:17 -04003084 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 pSMB->MaxSetupCount = 0;
3086 pSMB->Reserved = 0;
3087 pSMB->Flags = 0;
3088 pSMB->Timeout = 0;
3089 pSMB->Reserved2 = 0;
3090 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00003091 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003092 pSMB->DataCount = 0;
3093 pSMB->DataOffset = 0;
3094 pSMB->SetupCount = 1;
3095 pSMB->Reserved3 = 0;
3096 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3097 byte_count = params + 1 /* pad */ ;
3098 pSMB->TotalParameterCount = cpu_to_le16(params);
3099 pSMB->ParameterCount = pSMB->TotalParameterCount;
3100 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3101 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003102 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 pSMB->ByteCount = cpu_to_le16(byte_count);
3104
3105 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3106 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3107 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003108 cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003109 } else {
3110 /* decode response */
3111
3112 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003114 if (rc || get_bcc(&pSMBr->hdr) < 2)
Jeff Layton460b9692009-04-30 07:17:56 -04003115 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116 else {
Steve French0e0d2cf2009-05-01 05:27:32 +00003117 bool is_unicode;
Jeff Layton460b9692009-04-30 07:17:56 -04003118 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119
Jeff Layton460b9692009-04-30 07:17:56 -04003120 data_start = ((char *) &pSMBr->hdr.Protocol) +
3121 le16_to_cpu(pSMBr->t2.DataOffset);
3122
Steve French0e0d2cf2009-05-01 05:27:32 +00003123 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3124 is_unicode = true;
3125 else
3126 is_unicode = false;
3127
Steve French737b7582005-04-28 22:41:06 -07003128 /* BB FIXME investigate remapping reserved chars here */
Steve Frenchd185cda2009-04-30 17:45:10 +00003129 *symlinkinfo = cifs_strndup_from_ucs(data_start, count,
Steve French0e0d2cf2009-05-01 05:27:32 +00003130 is_unicode, nls_codepage);
Jeff Layton8b6427a2009-05-19 09:57:03 -04003131 if (!*symlinkinfo)
Jeff Layton460b9692009-04-30 07:17:56 -04003132 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003133 }
3134 }
3135 cifs_buf_release(pSMB);
3136 if (rc == -EAGAIN)
3137 goto querySymLinkRetry;
3138 return rc;
3139}
3140
Steve Frenchc52a9552011-02-24 06:16:22 +00003141#ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
3142/*
3143 * Recent Windows versions now create symlinks more frequently
3144 * and they use the "reparse point" mechanism below. We can of course
3145 * do symlinks nicely to Samba and other servers which support the
3146 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3147 * "MF" symlinks optionally, but for recent Windows we really need to
3148 * reenable the code below and fix the cifs_symlink callers to handle this.
3149 * In the interim this code has been moved to its own config option so
3150 * it is not compiled in by default until callers fixed up and more tested.
3151 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152int
Steve French96daf2b2011-05-27 04:34:02 +00003153CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 const unsigned char *searchName,
Steve French50c2f752007-07-13 00:33:32 +00003155 char *symlinkinfo, const int buflen, __u16 fid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 const struct nls_table *nls_codepage)
3157{
3158 int rc = 0;
3159 int bytes_returned;
Steve French50c2f752007-07-13 00:33:32 +00003160 struct smb_com_transaction_ioctl_req *pSMB;
3161 struct smb_com_transaction_ioctl_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162
Joe Perchesb6b38f72010-04-21 03:50:45 +00003163 cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3165 (void **) &pSMBr);
3166 if (rc)
3167 return rc;
3168
3169 pSMB->TotalParameterCount = 0 ;
3170 pSMB->TotalDataCount = 0;
3171 pSMB->MaxParameterCount = cpu_to_le32(2);
3172 /* BB find exact data count max from sess structure BB */
Jeff Laytonc974bef2011-10-11 06:41:32 -04003173 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 pSMB->MaxSetupCount = 4;
3175 pSMB->Reserved = 0;
3176 pSMB->ParameterOffset = 0;
3177 pSMB->DataCount = 0;
3178 pSMB->DataOffset = 0;
3179 pSMB->SetupCount = 4;
3180 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3181 pSMB->ParameterCount = pSMB->TotalParameterCount;
3182 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3183 pSMB->IsFsctl = 1; /* FSCTL */
3184 pSMB->IsRootFlag = 0;
3185 pSMB->Fid = fid; /* file handle always le */
3186 pSMB->ByteCount = 0;
3187
3188 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3189 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3190 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003191 cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003192 } else { /* decode response */
3193 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
3194 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
Jeff Layton820a8032011-05-04 08:05:26 -04003195 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3196 /* BB also check enough total bytes returned */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197 rc = -EIO; /* bad smb */
Steve Frenchafe48c32009-05-02 05:25:46 +00003198 goto qreparse_out;
3199 }
3200 if (data_count && (data_count < 2048)) {
3201 char *end_of_smb = 2 /* sizeof byte count */ +
Jeff Layton820a8032011-05-04 08:05:26 -04003202 get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203
Steve Frenchafe48c32009-05-02 05:25:46 +00003204 struct reparse_data *reparse_buf =
Steve French50c2f752007-07-13 00:33:32 +00003205 (struct reparse_data *)
3206 ((char *)&pSMBr->hdr.Protocol
3207 + data_offset);
Steve Frenchafe48c32009-05-02 05:25:46 +00003208 if ((char *)reparse_buf >= end_of_smb) {
3209 rc = -EIO;
3210 goto qreparse_out;
3211 }
3212 if ((reparse_buf->LinkNamesBuf +
3213 reparse_buf->TargetNameOffset +
3214 reparse_buf->TargetNameLen) > end_of_smb) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003215 cFYI(1, "reparse buf beyond SMB");
Steve Frenchafe48c32009-05-02 05:25:46 +00003216 rc = -EIO;
3217 goto qreparse_out;
3218 }
Steve French50c2f752007-07-13 00:33:32 +00003219
Steve Frenchafe48c32009-05-02 05:25:46 +00003220 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3221 cifs_from_ucs2(symlinkinfo, (__le16 *)
Steve French50c2f752007-07-13 00:33:32 +00003222 (reparse_buf->LinkNamesBuf +
3223 reparse_buf->TargetNameOffset),
Steve Frenchafe48c32009-05-02 05:25:46 +00003224 buflen,
3225 reparse_buf->TargetNameLen,
3226 nls_codepage, 0);
3227 } else { /* ASCII names */
3228 strncpy(symlinkinfo,
3229 reparse_buf->LinkNamesBuf +
3230 reparse_buf->TargetNameOffset,
3231 min_t(const int, buflen,
3232 reparse_buf->TargetNameLen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003233 }
Steve Frenchafe48c32009-05-02 05:25:46 +00003234 } else {
3235 rc = -EIO;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003236 cFYI(1, "Invalid return data count on "
3237 "get reparse info ioctl");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 }
Steve Frenchafe48c32009-05-02 05:25:46 +00003239 symlinkinfo[buflen] = 0; /* just in case so the caller
3240 does not go off the end of the buffer */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003241 cFYI(1, "readlink result - %s", symlinkinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003242 }
Steve French989c7e52009-05-02 05:32:20 +00003243
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244qreparse_out:
Steve French4a6d87f2005-08-13 08:15:54 -07003245 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246
3247 /* Note: On -EAGAIN error only caller can retry on handle based calls
3248 since file handle passed in no longer valid */
3249
3250 return rc;
3251}
Steve Frenchc52a9552011-02-24 06:16:22 +00003252#endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253
3254#ifdef CONFIG_CIFS_POSIX
3255
3256/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
Steve French50c2f752007-07-13 00:33:32 +00003257static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3258 struct cifs_posix_ace *cifs_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259{
3260 /* u8 cifs fields do not need le conversion */
Steve Frenchff7feac2005-11-15 16:45:16 -08003261 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3262 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3263 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
Joe Perchesb6b38f72010-04-21 03:50:45 +00003264 /* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003265
3266 return;
3267}
3268
3269/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
Steve French50c2f752007-07-13 00:33:32 +00003270static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3271 const int acl_type, const int size_of_data_area)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272{
3273 int size = 0;
3274 int i;
3275 __u16 count;
Steve French50c2f752007-07-13 00:33:32 +00003276 struct cifs_posix_ace *pACE;
3277 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3278 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279
3280 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3281 return -EOPNOTSUPP;
3282
Steve French790fe572007-07-07 19:25:05 +00003283 if (acl_type & ACL_TYPE_ACCESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284 count = le16_to_cpu(cifs_acl->access_entry_count);
3285 pACE = &cifs_acl->ace_array[0];
3286 size = sizeof(struct cifs_posix_acl);
3287 size += sizeof(struct cifs_posix_ace) * count;
3288 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003289 if (size_of_data_area < size) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003290 cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
3291 size_of_data_area, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 return -EINVAL;
3293 }
Steve French790fe572007-07-07 19:25:05 +00003294 } else if (acl_type & ACL_TYPE_DEFAULT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003295 count = le16_to_cpu(cifs_acl->access_entry_count);
3296 size = sizeof(struct cifs_posix_acl);
3297 size += sizeof(struct cifs_posix_ace) * count;
3298/* skip past access ACEs to get to default ACEs */
3299 pACE = &cifs_acl->ace_array[count];
3300 count = le16_to_cpu(cifs_acl->default_entry_count);
3301 size += sizeof(struct cifs_posix_ace) * count;
3302 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003303 if (size_of_data_area < size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304 return -EINVAL;
3305 } else {
3306 /* illegal type */
3307 return -EINVAL;
3308 }
3309
3310 size = posix_acl_xattr_size(count);
Steve French790fe572007-07-07 19:25:05 +00003311 if ((buflen == 0) || (local_acl == NULL)) {
Steve French50c2f752007-07-13 00:33:32 +00003312 /* used to query ACL EA size */
Steve French790fe572007-07-07 19:25:05 +00003313 } else if (size > buflen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 return -ERANGE;
3315 } else /* buffer big enough */ {
Steve Frenchff7feac2005-11-15 16:45:16 -08003316 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
Steve French50c2f752007-07-13 00:33:32 +00003317 for (i = 0; i < count ; i++) {
3318 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3319 pACE++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 }
3321 }
3322 return size;
3323}
3324
Steve French50c2f752007-07-13 00:33:32 +00003325static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3326 const posix_acl_xattr_entry *local_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327{
3328 __u16 rc = 0; /* 0 = ACL converted ok */
3329
Steve Frenchff7feac2005-11-15 16:45:16 -08003330 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3331 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 /* BB is there a better way to handle the large uid? */
Steve French790fe572007-07-07 19:25:05 +00003333 if (local_ace->e_id == cpu_to_le32(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 /* Probably no need to le convert -1 on any arch but can not hurt */
3335 cifs_ace->cifs_uid = cpu_to_le64(-1);
Steve French50c2f752007-07-13 00:33:32 +00003336 } else
Steve Frenchff7feac2005-11-15 16:45:16 -08003337 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
Joe Perchesb6b38f72010-04-21 03:50:45 +00003338 /*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339 return rc;
3340}
3341
3342/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
Steve French50c2f752007-07-13 00:33:32 +00003343static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3344 const int buflen, const int acl_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345{
3346 __u16 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00003347 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3348 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349 int count;
3350 int i;
3351
Steve French790fe572007-07-07 19:25:05 +00003352 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353 return 0;
3354
3355 count = posix_acl_xattr_count((size_t)buflen);
Joe Perchesb6b38f72010-04-21 03:50:45 +00003356 cFYI(1, "setting acl with %d entries from buf of length %d and "
Steve French63135e02007-07-17 17:34:02 +00003357 "version of %d",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003358 count, buflen, le32_to_cpu(local_acl->a_version));
Steve French790fe572007-07-07 19:25:05 +00003359 if (le32_to_cpu(local_acl->a_version) != 2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003360 cFYI(1, "unknown POSIX ACL version %d",
3361 le32_to_cpu(local_acl->a_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362 return 0;
3363 }
3364 cifs_acl->version = cpu_to_le16(1);
Steve French790fe572007-07-07 19:25:05 +00003365 if (acl_type == ACL_TYPE_ACCESS)
Steve Frenchff7feac2005-11-15 16:45:16 -08003366 cifs_acl->access_entry_count = cpu_to_le16(count);
Steve French790fe572007-07-07 19:25:05 +00003367 else if (acl_type == ACL_TYPE_DEFAULT)
Steve Frenchff7feac2005-11-15 16:45:16 -08003368 cifs_acl->default_entry_count = cpu_to_le16(count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003369 else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003370 cFYI(1, "unknown ACL type %d", acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003371 return 0;
3372 }
Steve French50c2f752007-07-13 00:33:32 +00003373 for (i = 0; i < count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3375 &local_acl->a_entries[i]);
Steve French790fe572007-07-07 19:25:05 +00003376 if (rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377 /* ACE not converted */
3378 break;
3379 }
3380 }
Steve French790fe572007-07-07 19:25:05 +00003381 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3383 rc += sizeof(struct cifs_posix_acl);
3384 /* BB add check to make sure ACL does not overflow SMB */
3385 }
3386 return rc;
3387}
3388
3389int
Steve French96daf2b2011-05-27 04:34:02 +00003390CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003391 const unsigned char *searchName,
3392 char *acl_inf, const int buflen, const int acl_type,
3393 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394{
3395/* SMB_QUERY_POSIX_ACL */
3396 TRANSACTION2_QPI_REQ *pSMB = NULL;
3397 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3398 int rc = 0;
3399 int bytes_returned;
3400 int name_len;
3401 __u16 params, byte_count;
Steve French50c2f752007-07-13 00:33:32 +00003402
Joe Perchesb6b38f72010-04-21 03:50:45 +00003403 cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404
3405queryAclRetry:
3406 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3407 (void **) &pSMBr);
3408 if (rc)
3409 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003410
Linus Torvalds1da177e2005-04-16 15:20:36 -07003411 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3412 name_len =
Steve French50c2f752007-07-13 00:33:32 +00003413 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French737b7582005-04-28 22:41:06 -07003414 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003415 name_len++; /* trailing null */
3416 name_len *= 2;
3417 pSMB->FileName[name_len] = 0;
3418 pSMB->FileName[name_len+1] = 0;
Steve French50c2f752007-07-13 00:33:32 +00003419 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003420 name_len = strnlen(searchName, PATH_MAX);
3421 name_len++; /* trailing null */
3422 strncpy(pSMB->FileName, searchName, name_len);
3423 }
3424
3425 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3426 pSMB->TotalDataCount = 0;
3427 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French50c2f752007-07-13 00:33:32 +00003428 /* BB find exact max data count below from sess structure BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003429 pSMB->MaxDataCount = cpu_to_le16(4000);
3430 pSMB->MaxSetupCount = 0;
3431 pSMB->Reserved = 0;
3432 pSMB->Flags = 0;
3433 pSMB->Timeout = 0;
3434 pSMB->Reserved2 = 0;
3435 pSMB->ParameterOffset = cpu_to_le16(
Steve French50c2f752007-07-13 00:33:32 +00003436 offsetof(struct smb_com_transaction2_qpi_req,
3437 InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 pSMB->DataCount = 0;
3439 pSMB->DataOffset = 0;
3440 pSMB->SetupCount = 1;
3441 pSMB->Reserved3 = 0;
3442 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3443 byte_count = params + 1 /* pad */ ;
3444 pSMB->TotalParameterCount = cpu_to_le16(params);
3445 pSMB->ParameterCount = pSMB->TotalParameterCount;
3446 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3447 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003448 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 pSMB->ByteCount = cpu_to_le16(byte_count);
3450
3451 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3452 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French0a4b92c2006-01-12 15:44:21 -08003453 cifs_stats_inc(&tcon->num_acl_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003455 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003456 } else {
3457 /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00003458
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003461 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 rc = -EIO; /* bad smb */
3463 else {
3464 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3465 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3466 rc = cifs_copy_posix_acl(acl_inf,
3467 (char *)&pSMBr->hdr.Protocol+data_offset,
Steve French50c2f752007-07-13 00:33:32 +00003468 buflen, acl_type, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469 }
3470 }
3471 cifs_buf_release(pSMB);
3472 if (rc == -EAGAIN)
3473 goto queryAclRetry;
3474 return rc;
3475}
3476
3477int
Steve French96daf2b2011-05-27 04:34:02 +00003478CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003479 const unsigned char *fileName,
3480 const char *local_acl, const int buflen,
3481 const int acl_type,
3482 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003483{
3484 struct smb_com_transaction2_spi_req *pSMB = NULL;
3485 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3486 char *parm_data;
3487 int name_len;
3488 int rc = 0;
3489 int bytes_returned = 0;
3490 __u16 params, byte_count, data_count, param_offset, offset;
3491
Joe Perchesb6b38f72010-04-21 03:50:45 +00003492 cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493setAclRetry:
3494 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003495 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 if (rc)
3497 return rc;
3498 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3499 name_len =
Steve French50c2f752007-07-13 00:33:32 +00003500 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
Steve French737b7582005-04-28 22:41:06 -07003501 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502 name_len++; /* trailing null */
3503 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003504 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 name_len = strnlen(fileName, PATH_MAX);
3506 name_len++; /* trailing null */
3507 strncpy(pSMB->FileName, fileName, name_len);
3508 }
3509 params = 6 + name_len;
3510 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00003511 /* BB find max SMB size from sess */
3512 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 pSMB->MaxSetupCount = 0;
3514 pSMB->Reserved = 0;
3515 pSMB->Flags = 0;
3516 pSMB->Timeout = 0;
3517 pSMB->Reserved2 = 0;
3518 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00003519 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 offset = param_offset + params;
3521 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3522 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3523
3524 /* convert to on the wire format for POSIX ACL */
Steve French50c2f752007-07-13 00:33:32 +00003525 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526
Steve French790fe572007-07-07 19:25:05 +00003527 if (data_count == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003528 rc = -EOPNOTSUPP;
3529 goto setACLerrorExit;
3530 }
3531 pSMB->DataOffset = cpu_to_le16(offset);
3532 pSMB->SetupCount = 1;
3533 pSMB->Reserved3 = 0;
3534 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3535 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3536 byte_count = 3 /* pad */ + params + data_count;
3537 pSMB->DataCount = cpu_to_le16(data_count);
3538 pSMB->TotalDataCount = pSMB->DataCount;
3539 pSMB->ParameterCount = cpu_to_le16(params);
3540 pSMB->TotalParameterCount = pSMB->ParameterCount;
3541 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003542 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003543 pSMB->ByteCount = cpu_to_le16(byte_count);
3544 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003545 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00003546 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003547 cFYI(1, "Set POSIX ACL returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548
3549setACLerrorExit:
3550 cifs_buf_release(pSMB);
3551 if (rc == -EAGAIN)
3552 goto setAclRetry;
3553 return rc;
3554}
3555
Steve Frenchf654bac2005-04-28 22:41:04 -07003556/* BB fix tabs in this function FIXME BB */
3557int
Steve French96daf2b2011-05-27 04:34:02 +00003558CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +00003559 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
Steve Frenchf654bac2005-04-28 22:41:04 -07003560{
Steve French50c2f752007-07-13 00:33:32 +00003561 int rc = 0;
3562 struct smb_t2_qfi_req *pSMB = NULL;
3563 struct smb_t2_qfi_rsp *pSMBr = NULL;
3564 int bytes_returned;
3565 __u16 params, byte_count;
Steve Frenchf654bac2005-04-28 22:41:04 -07003566
Joe Perchesb6b38f72010-04-21 03:50:45 +00003567 cFYI(1, "In GetExtAttr");
Steve French790fe572007-07-07 19:25:05 +00003568 if (tcon == NULL)
3569 return -ENODEV;
Steve Frenchf654bac2005-04-28 22:41:04 -07003570
3571GetExtAttrRetry:
Steve French790fe572007-07-07 19:25:05 +00003572 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3573 (void **) &pSMBr);
3574 if (rc)
3575 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003576
Steve Frenchad7a2922008-02-07 23:25:02 +00003577 params = 2 /* level */ + 2 /* fid */;
Steve French790fe572007-07-07 19:25:05 +00003578 pSMB->t2.TotalDataCount = 0;
3579 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3580 /* BB find exact max data count below from sess structure BB */
3581 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3582 pSMB->t2.MaxSetupCount = 0;
3583 pSMB->t2.Reserved = 0;
3584 pSMB->t2.Flags = 0;
3585 pSMB->t2.Timeout = 0;
3586 pSMB->t2.Reserved2 = 0;
3587 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3588 Fid) - 4);
3589 pSMB->t2.DataCount = 0;
3590 pSMB->t2.DataOffset = 0;
3591 pSMB->t2.SetupCount = 1;
3592 pSMB->t2.Reserved3 = 0;
3593 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3594 byte_count = params + 1 /* pad */ ;
3595 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3596 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3597 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3598 pSMB->Pad = 0;
Steve Frenchf654bac2005-04-28 22:41:04 -07003599 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003600 inc_rfc1001_len(pSMB, byte_count);
Steve French790fe572007-07-07 19:25:05 +00003601 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
Steve Frenchf654bac2005-04-28 22:41:04 -07003602
Steve French790fe572007-07-07 19:25:05 +00003603 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3604 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3605 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003606 cFYI(1, "error %d in GetExtAttr", rc);
Steve French790fe572007-07-07 19:25:05 +00003607 } else {
3608 /* decode response */
3609 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00003610 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003611 if (rc || get_bcc(&pSMBr->hdr) < 2)
Steve French790fe572007-07-07 19:25:05 +00003612 /* If rc should we check for EOPNOSUPP and
3613 disable the srvino flag? or in caller? */
3614 rc = -EIO; /* bad smb */
3615 else {
3616 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3617 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3618 struct file_chattr_info *pfinfo;
3619 /* BB Do we need a cast or hash here ? */
3620 if (count != 16) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003621 cFYI(1, "Illegal size ret in GetExtAttr");
Steve French790fe572007-07-07 19:25:05 +00003622 rc = -EIO;
3623 goto GetExtAttrOut;
3624 }
3625 pfinfo = (struct file_chattr_info *)
3626 (data_offset + (char *) &pSMBr->hdr.Protocol);
3627 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
Steve Frenchf654bac2005-04-28 22:41:04 -07003628 *pMask = le64_to_cpu(pfinfo->mask);
Steve French790fe572007-07-07 19:25:05 +00003629 }
3630 }
Steve Frenchf654bac2005-04-28 22:41:04 -07003631GetExtAttrOut:
Steve French790fe572007-07-07 19:25:05 +00003632 cifs_buf_release(pSMB);
3633 if (rc == -EAGAIN)
3634 goto GetExtAttrRetry;
3635 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003636}
3637
Steve Frenchf654bac2005-04-28 22:41:04 -07003638#endif /* CONFIG_POSIX */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639
Jeff Layton79df1ba2010-12-06 12:52:08 -05003640#ifdef CONFIG_CIFS_ACL
3641/*
3642 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3643 * all NT TRANSACTS that we init here have total parm and data under about 400
3644 * bytes (to fit in small cifs buffer size), which is the case so far, it
3645 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3646 * returned setup area) and MaxParameterCount (returned parms size) must be set
3647 * by caller
3648 */
3649static int
3650smb_init_nttransact(const __u16 sub_command, const int setup_count,
Steve French96daf2b2011-05-27 04:34:02 +00003651 const int parm_len, struct cifs_tcon *tcon,
Jeff Layton79df1ba2010-12-06 12:52:08 -05003652 void **ret_buf)
3653{
3654 int rc;
3655 __u32 temp_offset;
3656 struct smb_com_ntransact_req *pSMB;
3657
3658 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3659 (void **)&pSMB);
3660 if (rc)
3661 return rc;
3662 *ret_buf = (void *)pSMB;
3663 pSMB->Reserved = 0;
3664 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3665 pSMB->TotalDataCount = 0;
Jeff Laytonc974bef2011-10-11 06:41:32 -04003666 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Jeff Layton79df1ba2010-12-06 12:52:08 -05003667 pSMB->ParameterCount = pSMB->TotalParameterCount;
3668 pSMB->DataCount = pSMB->TotalDataCount;
3669 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3670 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3671 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3672 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3673 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3674 pSMB->SubCommand = cpu_to_le16(sub_command);
3675 return 0;
3676}
3677
3678static int
3679validate_ntransact(char *buf, char **ppparm, char **ppdata,
3680 __u32 *pparmlen, __u32 *pdatalen)
3681{
3682 char *end_of_smb;
3683 __u32 data_count, data_offset, parm_count, parm_offset;
3684 struct smb_com_ntransact_rsp *pSMBr;
Jeff Layton820a8032011-05-04 08:05:26 -04003685 u16 bcc;
Jeff Layton79df1ba2010-12-06 12:52:08 -05003686
3687 *pdatalen = 0;
3688 *pparmlen = 0;
3689
3690 if (buf == NULL)
3691 return -EINVAL;
3692
3693 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3694
Jeff Layton820a8032011-05-04 08:05:26 -04003695 bcc = get_bcc(&pSMBr->hdr);
3696 end_of_smb = 2 /* sizeof byte count */ + bcc +
Jeff Layton79df1ba2010-12-06 12:52:08 -05003697 (char *)&pSMBr->ByteCount;
3698
3699 data_offset = le32_to_cpu(pSMBr->DataOffset);
3700 data_count = le32_to_cpu(pSMBr->DataCount);
3701 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3702 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3703
3704 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3705 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3706
3707 /* should we also check that parm and data areas do not overlap? */
3708 if (*ppparm > end_of_smb) {
3709 cFYI(1, "parms start after end of smb");
3710 return -EINVAL;
3711 } else if (parm_count + *ppparm > end_of_smb) {
3712 cFYI(1, "parm end after end of smb");
3713 return -EINVAL;
3714 } else if (*ppdata > end_of_smb) {
3715 cFYI(1, "data starts after end of smb");
3716 return -EINVAL;
3717 } else if (data_count + *ppdata > end_of_smb) {
3718 cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
3719 *ppdata, data_count, (data_count + *ppdata),
3720 end_of_smb, pSMBr);
3721 return -EINVAL;
Jeff Layton820a8032011-05-04 08:05:26 -04003722 } else if (parm_count + data_count > bcc) {
Jeff Layton79df1ba2010-12-06 12:52:08 -05003723 cFYI(1, "parm count and data count larger than SMB");
3724 return -EINVAL;
3725 }
3726 *pdatalen = data_count;
3727 *pparmlen = parm_count;
3728 return 0;
3729}
3730
Steve French0a4b92c2006-01-12 15:44:21 -08003731/* Get Security Descriptor (by handle) from remote server for a file or dir */
3732int
Steve French96daf2b2011-05-27 04:34:02 +00003733CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
Steve French630f3f02007-10-25 21:17:17 +00003734 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
Steve French0a4b92c2006-01-12 15:44:21 -08003735{
3736 int rc = 0;
3737 int buf_type = 0;
Steve Frenchad7a2922008-02-07 23:25:02 +00003738 QUERY_SEC_DESC_REQ *pSMB;
Steve French0a4b92c2006-01-12 15:44:21 -08003739 struct kvec iov[1];
3740
Joe Perchesb6b38f72010-04-21 03:50:45 +00003741 cFYI(1, "GetCifsACL");
Steve French0a4b92c2006-01-12 15:44:21 -08003742
Steve French630f3f02007-10-25 21:17:17 +00003743 *pbuflen = 0;
3744 *acl_inf = NULL;
3745
Steve Frenchb9c7a2b2007-10-26 23:40:20 +00003746 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
Steve French0a4b92c2006-01-12 15:44:21 -08003747 8 /* parm len */, tcon, (void **) &pSMB);
3748 if (rc)
3749 return rc;
3750
3751 pSMB->MaxParameterCount = cpu_to_le32(4);
3752 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3753 pSMB->MaxSetupCount = 0;
3754 pSMB->Fid = fid; /* file handle always le */
3755 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3756 CIFS_ACL_DACL);
3757 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003758 inc_rfc1001_len(pSMB, 11);
Steve French0a4b92c2006-01-12 15:44:21 -08003759 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003760 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French0a4b92c2006-01-12 15:44:21 -08003761
Steve Frencha761ac52007-10-18 21:45:27 +00003762 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
Jeff Layton77499812011-01-11 07:24:23 -05003763 0);
Steve French0a4b92c2006-01-12 15:44:21 -08003764 cifs_stats_inc(&tcon->num_acl_get);
3765 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003766 cFYI(1, "Send error in QuerySecDesc = %d", rc);
Steve French0a4b92c2006-01-12 15:44:21 -08003767 } else { /* decode response */
Steve Frenchad7a2922008-02-07 23:25:02 +00003768 __le32 *parm;
Steve French630f3f02007-10-25 21:17:17 +00003769 __u32 parm_len;
3770 __u32 acl_len;
Steve French50c2f752007-07-13 00:33:32 +00003771 struct smb_com_ntransact_rsp *pSMBr;
Steve French630f3f02007-10-25 21:17:17 +00003772 char *pdata;
Steve French0a4b92c2006-01-12 15:44:21 -08003773
3774/* validate_nttransact */
Steve French50c2f752007-07-13 00:33:32 +00003775 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
Steve French630f3f02007-10-25 21:17:17 +00003776 &pdata, &parm_len, pbuflen);
Steve French790fe572007-07-07 19:25:05 +00003777 if (rc)
Steve French0a4b92c2006-01-12 15:44:21 -08003778 goto qsec_out;
3779 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3780
Joe Perchesb6b38f72010-04-21 03:50:45 +00003781 cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
Steve French0a4b92c2006-01-12 15:44:21 -08003782
3783 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3784 rc = -EIO; /* bad smb */
Steve French630f3f02007-10-25 21:17:17 +00003785 *pbuflen = 0;
Steve French0a4b92c2006-01-12 15:44:21 -08003786 goto qsec_out;
3787 }
3788
3789/* BB check that data area is minimum length and as big as acl_len */
3790
Steve Frenchaf6f4612007-10-16 18:40:37 +00003791 acl_len = le32_to_cpu(*parm);
Steve French630f3f02007-10-25 21:17:17 +00003792 if (acl_len != *pbuflen) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003793 cERROR(1, "acl length %d does not match %d",
3794 acl_len, *pbuflen);
Steve French630f3f02007-10-25 21:17:17 +00003795 if (*pbuflen > acl_len)
3796 *pbuflen = acl_len;
3797 }
Steve French0a4b92c2006-01-12 15:44:21 -08003798
Steve French630f3f02007-10-25 21:17:17 +00003799 /* check if buffer is big enough for the acl
3800 header followed by the smallest SID */
3801 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3802 (*pbuflen >= 64 * 1024)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003803 cERROR(1, "bad acl length %d", *pbuflen);
Steve French630f3f02007-10-25 21:17:17 +00003804 rc = -EINVAL;
3805 *pbuflen = 0;
3806 } else {
3807 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3808 if (*acl_inf == NULL) {
3809 *pbuflen = 0;
3810 rc = -ENOMEM;
3811 }
3812 memcpy(*acl_inf, pdata, *pbuflen);
3813 }
Steve French0a4b92c2006-01-12 15:44:21 -08003814 }
3815qsec_out:
Steve French790fe572007-07-07 19:25:05 +00003816 if (buf_type == CIFS_SMALL_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003817 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00003818 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003819 cifs_buf_release(iov[0].iov_base);
Steve French4b8f9302006-02-26 16:41:18 +00003820/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French0a4b92c2006-01-12 15:44:21 -08003821 return rc;
3822}
Steve French97837582007-12-31 07:47:21 +00003823
3824int
Steve French96daf2b2011-05-27 04:34:02 +00003825CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003826 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
Steve French97837582007-12-31 07:47:21 +00003827{
3828 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3829 int rc = 0;
3830 int bytes_returned = 0;
3831 SET_SEC_DESC_REQ *pSMB = NULL;
3832 NTRANSACT_RSP *pSMBr = NULL;
3833
3834setCifsAclRetry:
3835 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3836 (void **) &pSMBr);
3837 if (rc)
3838 return (rc);
3839
3840 pSMB->MaxSetupCount = 0;
3841 pSMB->Reserved = 0;
3842
3843 param_count = 8;
3844 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3845 data_count = acllen;
3846 data_offset = param_offset + param_count;
3847 byte_count = 3 /* pad */ + param_count;
3848
3849 pSMB->DataCount = cpu_to_le32(data_count);
3850 pSMB->TotalDataCount = pSMB->DataCount;
3851 pSMB->MaxParameterCount = cpu_to_le32(4);
3852 pSMB->MaxDataCount = cpu_to_le32(16384);
3853 pSMB->ParameterCount = cpu_to_le32(param_count);
3854 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3855 pSMB->TotalParameterCount = pSMB->ParameterCount;
3856 pSMB->DataOffset = cpu_to_le32(data_offset);
3857 pSMB->SetupCount = 0;
3858 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3859 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3860
3861 pSMB->Fid = fid; /* file handle always le */
3862 pSMB->Reserved2 = 0;
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003863 pSMB->AclFlags = cpu_to_le32(aclflag);
Steve French97837582007-12-31 07:47:21 +00003864
3865 if (pntsd && acllen) {
3866 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3867 (char *) pntsd,
3868 acllen);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003869 inc_rfc1001_len(pSMB, byte_count + data_count);
Steve French97837582007-12-31 07:47:21 +00003870 } else
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003871 inc_rfc1001_len(pSMB, byte_count);
Steve French97837582007-12-31 07:47:21 +00003872
3873 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3874 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3875
Joe Perchesb6b38f72010-04-21 03:50:45 +00003876 cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
Steve French97837582007-12-31 07:47:21 +00003877 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003878 cFYI(1, "Set CIFS ACL returned %d", rc);
Steve French97837582007-12-31 07:47:21 +00003879 cifs_buf_release(pSMB);
3880
3881 if (rc == -EAGAIN)
3882 goto setCifsAclRetry;
3883
3884 return (rc);
3885}
3886
Jeff Layton79df1ba2010-12-06 12:52:08 -05003887#endif /* CONFIG_CIFS_ACL */
Steve French0a4b92c2006-01-12 15:44:21 -08003888
Steve French6b8edfe2005-08-23 20:26:03 -07003889/* Legacy Query Path Information call for lookup to old servers such
3890 as Win9x/WinME */
Steve French96daf2b2011-05-27 04:34:02 +00003891int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003892 const unsigned char *searchName,
3893 FILE_ALL_INFO *pFinfo,
3894 const struct nls_table *nls_codepage, int remap)
Steve French6b8edfe2005-08-23 20:26:03 -07003895{
Steve Frenchad7a2922008-02-07 23:25:02 +00003896 QUERY_INFORMATION_REQ *pSMB;
3897 QUERY_INFORMATION_RSP *pSMBr;
Steve French6b8edfe2005-08-23 20:26:03 -07003898 int rc = 0;
3899 int bytes_returned;
3900 int name_len;
3901
Joe Perchesb6b38f72010-04-21 03:50:45 +00003902 cFYI(1, "In SMBQPath path %s", searchName);
Steve French6b8edfe2005-08-23 20:26:03 -07003903QInfRetry:
3904 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003905 (void **) &pSMBr);
Steve French6b8edfe2005-08-23 20:26:03 -07003906 if (rc)
3907 return rc;
3908
3909 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3910 name_len =
Steve French50c2f752007-07-13 00:33:32 +00003911 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3912 PATH_MAX, nls_codepage, remap);
Steve French6b8edfe2005-08-23 20:26:03 -07003913 name_len++; /* trailing null */
3914 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003915 } else {
Steve French6b8edfe2005-08-23 20:26:03 -07003916 name_len = strnlen(searchName, PATH_MAX);
3917 name_len++; /* trailing null */
3918 strncpy(pSMB->FileName, searchName, name_len);
3919 }
3920 pSMB->BufferFormat = 0x04;
Steve French50c2f752007-07-13 00:33:32 +00003921 name_len++; /* account for buffer type byte */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003922 inc_rfc1001_len(pSMB, (__u16)name_len);
Steve French6b8edfe2005-08-23 20:26:03 -07003923 pSMB->ByteCount = cpu_to_le16(name_len);
3924
3925 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003926 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French6b8edfe2005-08-23 20:26:03 -07003927 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003928 cFYI(1, "Send error in QueryInfo = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00003929 } else if (pFinfo) {
Steve French1bd5bbc2006-09-28 03:35:57 +00003930 struct timespec ts;
3931 __u32 time = le32_to_cpu(pSMBr->last_write_time);
Steve Frenchad7a2922008-02-07 23:25:02 +00003932
3933 /* decode response */
Steve French1bd5bbc2006-09-28 03:35:57 +00003934 /* BB FIXME - add time zone adjustment BB */
Steve French6b8edfe2005-08-23 20:26:03 -07003935 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
Steve French1bd5bbc2006-09-28 03:35:57 +00003936 ts.tv_nsec = 0;
3937 ts.tv_sec = time;
3938 /* decode time fields */
Al Viro733f99a2006-10-14 16:48:26 +01003939 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
Steve French1bd5bbc2006-09-28 03:35:57 +00003940 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3941 pFinfo->LastAccessTime = 0;
Steve French70ca7342005-09-22 16:32:06 -07003942 pFinfo->AllocationSize =
3943 cpu_to_le64(le32_to_cpu(pSMBr->size));
3944 pFinfo->EndOfFile = pFinfo->AllocationSize;
3945 pFinfo->Attributes =
3946 cpu_to_le32(le16_to_cpu(pSMBr->attr));
Steve French6b8edfe2005-08-23 20:26:03 -07003947 } else
3948 rc = -EIO; /* bad buffer passed in */
3949
3950 cifs_buf_release(pSMB);
3951
3952 if (rc == -EAGAIN)
3953 goto QInfRetry;
3954
3955 return rc;
3956}
3957
Jeff Laytonbcd53572010-02-12 07:44:16 -05003958int
Steve French96daf2b2011-05-27 04:34:02 +00003959CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Laytonbcd53572010-02-12 07:44:16 -05003960 u16 netfid, FILE_ALL_INFO *pFindData)
3961{
3962 struct smb_t2_qfi_req *pSMB = NULL;
3963 struct smb_t2_qfi_rsp *pSMBr = NULL;
3964 int rc = 0;
3965 int bytes_returned;
3966 __u16 params, byte_count;
Steve French6b8edfe2005-08-23 20:26:03 -07003967
Jeff Laytonbcd53572010-02-12 07:44:16 -05003968QFileInfoRetry:
3969 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3970 (void **) &pSMBr);
3971 if (rc)
3972 return rc;
Steve French6b8edfe2005-08-23 20:26:03 -07003973
Jeff Laytonbcd53572010-02-12 07:44:16 -05003974 params = 2 /* level */ + 2 /* fid */;
3975 pSMB->t2.TotalDataCount = 0;
3976 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3977 /* BB find exact max data count below from sess structure BB */
3978 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3979 pSMB->t2.MaxSetupCount = 0;
3980 pSMB->t2.Reserved = 0;
3981 pSMB->t2.Flags = 0;
3982 pSMB->t2.Timeout = 0;
3983 pSMB->t2.Reserved2 = 0;
3984 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3985 Fid) - 4);
3986 pSMB->t2.DataCount = 0;
3987 pSMB->t2.DataOffset = 0;
3988 pSMB->t2.SetupCount = 1;
3989 pSMB->t2.Reserved3 = 0;
3990 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3991 byte_count = params + 1 /* pad */ ;
3992 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3993 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3994 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3995 pSMB->Pad = 0;
3996 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003997 inc_rfc1001_len(pSMB, byte_count);
Jeff Laytonbcd53572010-02-12 07:44:16 -05003998
3999 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4000 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4001 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004002 cFYI(1, "Send error in QPathInfo = %d", rc);
Jeff Laytonbcd53572010-02-12 07:44:16 -05004003 } else { /* decode response */
4004 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4005
4006 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4007 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004008 else if (get_bcc(&pSMBr->hdr) < 40)
Jeff Laytonbcd53572010-02-12 07:44:16 -05004009 rc = -EIO; /* bad smb */
4010 else if (pFindData) {
4011 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4012 memcpy((char *) pFindData,
4013 (char *) &pSMBr->hdr.Protocol +
4014 data_offset, sizeof(FILE_ALL_INFO));
4015 } else
4016 rc = -ENOMEM;
4017 }
4018 cifs_buf_release(pSMB);
4019 if (rc == -EAGAIN)
4020 goto QFileInfoRetry;
4021
4022 return rc;
4023}
Steve French6b8edfe2005-08-23 20:26:03 -07004024
Linus Torvalds1da177e2005-04-16 15:20:36 -07004025int
Steve French96daf2b2011-05-27 04:34:02 +00004026CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004027 const unsigned char *searchName,
Steve Frenchad7a2922008-02-07 23:25:02 +00004028 FILE_ALL_INFO *pFindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004029 int legacy /* old style infolevel */,
Steve French737b7582005-04-28 22:41:06 -07004030 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004031{
4032/* level 263 SMB_QUERY_FILE_ALL_INFO */
4033 TRANSACTION2_QPI_REQ *pSMB = NULL;
4034 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4035 int rc = 0;
4036 int bytes_returned;
4037 int name_len;
4038 __u16 params, byte_count;
4039
Joe Perchesb6b38f72010-04-21 03:50:45 +00004040/* cFYI(1, "In QPathInfo path %s", searchName); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004041QPathInfoRetry:
4042 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4043 (void **) &pSMBr);
4044 if (rc)
4045 return rc;
4046
4047 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4048 name_len =
Steve French50c2f752007-07-13 00:33:32 +00004049 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French737b7582005-04-28 22:41:06 -07004050 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051 name_len++; /* trailing null */
4052 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004053 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004054 name_len = strnlen(searchName, PATH_MAX);
4055 name_len++; /* trailing null */
4056 strncpy(pSMB->FileName, searchName, name_len);
4057 }
4058
Steve French50c2f752007-07-13 00:33:32 +00004059 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004060 pSMB->TotalDataCount = 0;
4061 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00004062 /* BB find exact max SMB PDU from sess structure BB */
4063 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004064 pSMB->MaxSetupCount = 0;
4065 pSMB->Reserved = 0;
4066 pSMB->Flags = 0;
4067 pSMB->Timeout = 0;
4068 pSMB->Reserved2 = 0;
4069 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004070 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004071 pSMB->DataCount = 0;
4072 pSMB->DataOffset = 0;
4073 pSMB->SetupCount = 1;
4074 pSMB->Reserved3 = 0;
4075 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4076 byte_count = params + 1 /* pad */ ;
4077 pSMB->TotalParameterCount = cpu_to_le16(params);
4078 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve French790fe572007-07-07 19:25:05 +00004079 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004080 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4081 else
4082 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004083 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004084 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085 pSMB->ByteCount = cpu_to_le16(byte_count);
4086
4087 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4088 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4089 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004090 cFYI(1, "Send error in QPathInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004091 } else { /* decode response */
4092 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4093
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004094 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4095 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004096 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004097 rc = -EIO; /* bad smb */
Jeff Layton820a8032011-05-04 08:05:26 -04004098 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
Steve French50c2f752007-07-13 00:33:32 +00004099 rc = -EIO; /* 24 or 26 expected but we do not read
4100 last field */
4101 else if (pFindData) {
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004102 int size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004103 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Steve Frenchad7a2922008-02-07 23:25:02 +00004104
4105 /* On legacy responses we do not read the last field,
4106 EAsize, fortunately since it varies by subdialect and
4107 also note it differs on Set vs. Get, ie two bytes or 4
4108 bytes depending but we don't care here */
4109 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004110 size = sizeof(FILE_INFO_STANDARD);
4111 else
4112 size = sizeof(FILE_ALL_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113 memcpy((char *) pFindData,
4114 (char *) &pSMBr->hdr.Protocol +
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004115 data_offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004116 } else
4117 rc = -ENOMEM;
4118 }
4119 cifs_buf_release(pSMB);
4120 if (rc == -EAGAIN)
4121 goto QPathInfoRetry;
4122
4123 return rc;
4124}
4125
4126int
Steve French96daf2b2011-05-27 04:34:02 +00004127CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004128 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4129{
4130 struct smb_t2_qfi_req *pSMB = NULL;
4131 struct smb_t2_qfi_rsp *pSMBr = NULL;
4132 int rc = 0;
4133 int bytes_returned;
4134 __u16 params, byte_count;
4135
4136UnixQFileInfoRetry:
4137 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4138 (void **) &pSMBr);
4139 if (rc)
4140 return rc;
4141
4142 params = 2 /* level */ + 2 /* fid */;
4143 pSMB->t2.TotalDataCount = 0;
4144 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4145 /* BB find exact max data count below from sess structure BB */
4146 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4147 pSMB->t2.MaxSetupCount = 0;
4148 pSMB->t2.Reserved = 0;
4149 pSMB->t2.Flags = 0;
4150 pSMB->t2.Timeout = 0;
4151 pSMB->t2.Reserved2 = 0;
4152 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4153 Fid) - 4);
4154 pSMB->t2.DataCount = 0;
4155 pSMB->t2.DataOffset = 0;
4156 pSMB->t2.SetupCount = 1;
4157 pSMB->t2.Reserved3 = 0;
4158 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4159 byte_count = params + 1 /* pad */ ;
4160 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4161 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4162 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4163 pSMB->Pad = 0;
4164 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004165 inc_rfc1001_len(pSMB, byte_count);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004166
4167 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4168 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4169 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004170 cFYI(1, "Send error in QPathInfo = %d", rc);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004171 } else { /* decode response */
4172 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4173
Jeff Layton820a8032011-05-04 08:05:26 -04004174 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004175 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004176 "Unix Extensions can be disabled on mount "
Steve Frenchf19159d2010-04-21 04:12:10 +00004177 "by specifying the nosfu mount option.");
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004178 rc = -EIO; /* bad smb */
4179 } else {
4180 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4181 memcpy((char *) pFindData,
4182 (char *) &pSMBr->hdr.Protocol +
4183 data_offset,
4184 sizeof(FILE_UNIX_BASIC_INFO));
4185 }
4186 }
4187
4188 cifs_buf_release(pSMB);
4189 if (rc == -EAGAIN)
4190 goto UnixQFileInfoRetry;
4191
4192 return rc;
4193}
4194
4195int
Steve French96daf2b2011-05-27 04:34:02 +00004196CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004197 const unsigned char *searchName,
Steve French582d21e2008-05-13 04:54:12 +00004198 FILE_UNIX_BASIC_INFO *pFindData,
Steve French737b7582005-04-28 22:41:06 -07004199 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004200{
4201/* SMB_QUERY_FILE_UNIX_BASIC */
4202 TRANSACTION2_QPI_REQ *pSMB = NULL;
4203 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4204 int rc = 0;
4205 int bytes_returned = 0;
4206 int name_len;
4207 __u16 params, byte_count;
4208
Joe Perchesb6b38f72010-04-21 03:50:45 +00004209 cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004210UnixQPathInfoRetry:
4211 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4212 (void **) &pSMBr);
4213 if (rc)
4214 return rc;
4215
4216 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4217 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05004218 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French737b7582005-04-28 22:41:06 -07004219 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004220 name_len++; /* trailing null */
4221 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004222 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 name_len = strnlen(searchName, PATH_MAX);
4224 name_len++; /* trailing null */
4225 strncpy(pSMB->FileName, searchName, name_len);
4226 }
4227
Steve French50c2f752007-07-13 00:33:32 +00004228 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229 pSMB->TotalDataCount = 0;
4230 pSMB->MaxParameterCount = cpu_to_le16(2);
4231 /* BB find exact max SMB PDU from sess structure BB */
Steve French50c2f752007-07-13 00:33:32 +00004232 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004233 pSMB->MaxSetupCount = 0;
4234 pSMB->Reserved = 0;
4235 pSMB->Flags = 0;
4236 pSMB->Timeout = 0;
4237 pSMB->Reserved2 = 0;
4238 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004239 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004240 pSMB->DataCount = 0;
4241 pSMB->DataOffset = 0;
4242 pSMB->SetupCount = 1;
4243 pSMB->Reserved3 = 0;
4244 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4245 byte_count = params + 1 /* pad */ ;
4246 pSMB->TotalParameterCount = cpu_to_le16(params);
4247 pSMB->ParameterCount = pSMB->TotalParameterCount;
4248 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4249 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004250 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004251 pSMB->ByteCount = cpu_to_le16(byte_count);
4252
4253 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4254 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4255 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004256 cFYI(1, "Send error in QPathInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004257 } else { /* decode response */
4258 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4259
Jeff Layton820a8032011-05-04 08:05:26 -04004260 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004261 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
Steve French1e71f252007-09-20 15:30:07 +00004262 "Unix Extensions can be disabled on mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00004263 "by specifying the nosfu mount option.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004264 rc = -EIO; /* bad smb */
4265 } else {
4266 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4267 memcpy((char *) pFindData,
4268 (char *) &pSMBr->hdr.Protocol +
4269 data_offset,
Steve French630f3f02007-10-25 21:17:17 +00004270 sizeof(FILE_UNIX_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004271 }
4272 }
4273 cifs_buf_release(pSMB);
4274 if (rc == -EAGAIN)
4275 goto UnixQPathInfoRetry;
4276
4277 return rc;
4278}
4279
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280/* xid, tcon, searchName and codepage are input parms, rest are returned */
4281int
Steve French96daf2b2011-05-27 04:34:02 +00004282CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004283 const char *searchName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 const struct nls_table *nls_codepage,
Steve French50c2f752007-07-13 00:33:32 +00004285 __u16 *pnetfid,
4286 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004287{
4288/* level 257 SMB_ */
4289 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4290 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004291 T2_FFIRST_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004292 int rc = 0;
4293 int bytes_returned = 0;
4294 int name_len;
4295 __u16 params, byte_count;
4296
Joe Perchesb6b38f72010-04-21 03:50:45 +00004297 cFYI(1, "In FindFirst for %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004298
4299findFirstRetry:
4300 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4301 (void **) &pSMBr);
4302 if (rc)
4303 return rc;
4304
4305 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4306 name_len =
Steve French50c2f752007-07-13 00:33:32 +00004307 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French737b7582005-04-28 22:41:06 -07004308 PATH_MAX, nls_codepage, remap);
4309 /* We can not add the asterik earlier in case
4310 it got remapped to 0xF03A as if it were part of the
4311 directory name instead of a wildcard */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004312 name_len *= 2;
Jeremy Allisonac670552005-06-22 17:26:35 -07004313 pSMB->FileName[name_len] = dirsep;
Steve French737b7582005-04-28 22:41:06 -07004314 pSMB->FileName[name_len+1] = 0;
4315 pSMB->FileName[name_len+2] = '*';
4316 pSMB->FileName[name_len+3] = 0;
4317 name_len += 4; /* now the trailing null */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004318 pSMB->FileName[name_len] = 0; /* null terminate just in case */
4319 pSMB->FileName[name_len+1] = 0;
Steve French737b7582005-04-28 22:41:06 -07004320 name_len += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321 } else { /* BB add check for overrun of SMB buf BB */
4322 name_len = strnlen(searchName, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004323/* BB fix here and in unicode clause above ie
Steve French790fe572007-07-07 19:25:05 +00004324 if (name_len > buffersize-header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 free buffer exit; BB */
4326 strncpy(pSMB->FileName, searchName, name_len);
Jeremy Allisonac670552005-06-22 17:26:35 -07004327 pSMB->FileName[name_len] = dirsep;
Steve French68575472005-04-30 11:10:57 -07004328 pSMB->FileName[name_len+1] = '*';
4329 pSMB->FileName[name_len+2] = 0;
4330 name_len += 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331 }
4332
4333 params = 12 + name_len /* includes null */ ;
4334 pSMB->TotalDataCount = 0; /* no EAs */
4335 pSMB->MaxParameterCount = cpu_to_le16(10);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004336 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004337 pSMB->MaxSetupCount = 0;
4338 pSMB->Reserved = 0;
4339 pSMB->Flags = 0;
4340 pSMB->Timeout = 0;
4341 pSMB->Reserved2 = 0;
4342 byte_count = params + 1 /* pad */ ;
4343 pSMB->TotalParameterCount = cpu_to_le16(params);
4344 pSMB->ParameterCount = pSMB->TotalParameterCount;
4345 pSMB->ParameterOffset = cpu_to_le16(
Steve French88274812006-03-09 22:21:45 +00004346 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4347 - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004348 pSMB->DataCount = 0;
4349 pSMB->DataOffset = 0;
4350 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4351 pSMB->Reserved3 = 0;
4352 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4353 pSMB->SearchAttributes =
4354 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4355 ATTR_DIRECTORY);
Steve French50c2f752007-07-13 00:33:32 +00004356 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4357 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
Linus Torvalds1da177e2005-04-16 15:20:36 -07004358 CIFS_SEARCH_RETURN_RESUME);
4359 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4360
4361 /* BB what should we set StorageType to? Does it matter? BB */
4362 pSMB->SearchStorageType = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004363 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004364 pSMB->ByteCount = cpu_to_le16(byte_count);
4365
4366 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4367 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07004368 cifs_stats_inc(&tcon->num_ffirst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004369
Steve French88274812006-03-09 22:21:45 +00004370 if (rc) {/* BB add logic to retry regular search if Unix search
4371 rejected unexpectedly by server */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004372 /* BB Add code to handle unsupported level rc */
Joe Perchesb6b38f72010-04-21 03:50:45 +00004373 cFYI(1, "Error in FindFirst = %d", rc);
Steve French1982c342005-08-17 12:38:22 -07004374
Steve French88274812006-03-09 22:21:45 +00004375 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004376
4377 /* BB eventually could optimize out free and realloc of buf */
4378 /* for this case */
4379 if (rc == -EAGAIN)
4380 goto findFirstRetry;
4381 } else { /* decode response */
4382 /* BB remember to free buffer if error BB */
4383 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00004384 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004385 unsigned int lnoff;
4386
Linus Torvalds1da177e2005-04-16 15:20:36 -07004387 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004388 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004389 else
Steve French4b18f2a2008-04-29 00:06:05 +00004390 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391
4392 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004393 psrch_inf->smallBuf = 0;
Steve French50c2f752007-07-13 00:33:32 +00004394 psrch_inf->srch_entries_start =
4395 (char *) &pSMBr->hdr.Protocol +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004396 le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004397 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4398 le16_to_cpu(pSMBr->t2.ParameterOffset));
4399
Steve French790fe572007-07-07 19:25:05 +00004400 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004401 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402 else
Steve French4b18f2a2008-04-29 00:06:05 +00004403 psrch_inf->endOfSearch = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004404
Steve French50c2f752007-07-13 00:33:32 +00004405 psrch_inf->entries_in_buffer =
4406 le16_to_cpu(parms->SearchCount);
Steve French60808232006-04-22 15:53:05 +00004407 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004408 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004409 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004410 if (CIFSMaxBufSize < lnoff) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004411 cERROR(1, "ignoring corrupt resume name");
Steve Frenchb77d7532008-10-08 19:13:46 +00004412 psrch_inf->last_entry = NULL;
4413 return rc;
4414 }
4415
Steve French0752f152008-10-07 20:03:33 +00004416 psrch_inf->last_entry = psrch_inf->srch_entries_start +
Steve Frenchb77d7532008-10-08 19:13:46 +00004417 lnoff;
4418
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419 *pnetfid = parms->SearchHandle;
4420 } else {
4421 cifs_buf_release(pSMB);
4422 }
4423 }
4424
4425 return rc;
4426}
4427
Steve French96daf2b2011-05-27 04:34:02 +00004428int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004429 __u16 searchHandle, struct cifs_search_info *psrch_inf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004430{
4431 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4432 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004433 T2_FNEXT_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434 char *response_data;
4435 int rc = 0;
Jeff Layton9438fab2011-08-23 07:21:28 -04004436 int bytes_returned;
4437 unsigned int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004438 __u16 params, byte_count;
4439
Joe Perchesb6b38f72010-04-21 03:50:45 +00004440 cFYI(1, "In FindNext");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004441
Steve French4b18f2a2008-04-29 00:06:05 +00004442 if (psrch_inf->endOfSearch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004443 return -ENOENT;
4444
4445 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4446 (void **) &pSMBr);
4447 if (rc)
4448 return rc;
4449
Steve French50c2f752007-07-13 00:33:32 +00004450 params = 14; /* includes 2 bytes of null string, converted to LE below*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004451 byte_count = 0;
4452 pSMB->TotalDataCount = 0; /* no EAs */
4453 pSMB->MaxParameterCount = cpu_to_le16(8);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004454 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004455 pSMB->MaxSetupCount = 0;
4456 pSMB->Reserved = 0;
4457 pSMB->Flags = 0;
4458 pSMB->Timeout = 0;
4459 pSMB->Reserved2 = 0;
4460 pSMB->ParameterOffset = cpu_to_le16(
4461 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4462 pSMB->DataCount = 0;
4463 pSMB->DataOffset = 0;
4464 pSMB->SetupCount = 1;
4465 pSMB->Reserved3 = 0;
4466 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4467 pSMB->SearchHandle = searchHandle; /* always kept as le */
4468 pSMB->SearchCount =
Steve French630f3f02007-10-25 21:17:17 +00004469 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004470 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4471 pSMB->ResumeKey = psrch_inf->resume_key;
4472 pSMB->SearchFlags =
4473 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
4474
4475 name_len = psrch_inf->resume_name_len;
4476 params += name_len;
Steve French790fe572007-07-07 19:25:05 +00004477 if (name_len < PATH_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004478 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4479 byte_count += name_len;
Steve Frenchef6724e2005-08-02 21:31:05 -07004480 /* 14 byte parm len above enough for 2 byte null terminator */
4481 pSMB->ResumeFileName[name_len] = 0;
4482 pSMB->ResumeFileName[name_len+1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004483 } else {
4484 rc = -EINVAL;
4485 goto FNext2_err_exit;
4486 }
4487 byte_count = params + 1 /* pad */ ;
4488 pSMB->TotalParameterCount = cpu_to_le16(params);
4489 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004490 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004491 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00004492
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4494 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07004495 cifs_stats_inc(&tcon->num_fnext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004496 if (rc) {
4497 if (rc == -EBADF) {
Steve French4b18f2a2008-04-29 00:06:05 +00004498 psrch_inf->endOfSearch = true;
Jeff Layton63534502008-05-12 19:56:05 -07004499 cifs_buf_release(pSMB);
Steve French50c2f752007-07-13 00:33:32 +00004500 rc = 0; /* search probably was closed at end of search*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00004502 cFYI(1, "FindNext returned = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004503 } else { /* decode response */
4504 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French50c2f752007-07-13 00:33:32 +00004505
Steve French790fe572007-07-07 19:25:05 +00004506 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004507 unsigned int lnoff;
4508
Linus Torvalds1da177e2005-04-16 15:20:36 -07004509 /* BB fixme add lock for file (srch_info) struct here */
4510 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004511 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004512 else
Steve French4b18f2a2008-04-29 00:06:05 +00004513 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004514 response_data = (char *) &pSMBr->hdr.Protocol +
4515 le16_to_cpu(pSMBr->t2.ParameterOffset);
4516 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4517 response_data = (char *)&pSMBr->hdr.Protocol +
4518 le16_to_cpu(pSMBr->t2.DataOffset);
Steve French790fe572007-07-07 19:25:05 +00004519 if (psrch_inf->smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +00004520 cifs_small_buf_release(
4521 psrch_inf->ntwrk_buf_start);
4522 else
4523 cifs_buf_release(psrch_inf->ntwrk_buf_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004524 psrch_inf->srch_entries_start = response_data;
4525 psrch_inf->ntwrk_buf_start = (char *)pSMB;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004526 psrch_inf->smallBuf = 0;
Steve French790fe572007-07-07 19:25:05 +00004527 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004528 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004529 else
Steve French4b18f2a2008-04-29 00:06:05 +00004530 psrch_inf->endOfSearch = false;
Steve French50c2f752007-07-13 00:33:32 +00004531 psrch_inf->entries_in_buffer =
4532 le16_to_cpu(parms->SearchCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004533 psrch_inf->index_of_last_entry +=
4534 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004535 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004536 if (CIFSMaxBufSize < lnoff) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004537 cERROR(1, "ignoring corrupt resume name");
Steve Frenchb77d7532008-10-08 19:13:46 +00004538 psrch_inf->last_entry = NULL;
4539 return rc;
4540 } else
4541 psrch_inf->last_entry =
4542 psrch_inf->srch_entries_start + lnoff;
4543
Joe Perchesb6b38f72010-04-21 03:50:45 +00004544/* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
4545 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004546
4547 /* BB fixme add unlock here */
4548 }
4549
4550 }
4551
4552 /* BB On error, should we leave previous search buf (and count and
4553 last entry fields) intact or free the previous one? */
4554
4555 /* Note: On -EAGAIN error only caller can retry on handle based calls
4556 since file handle passed in no longer valid */
4557FNext2_err_exit:
4558 if (rc != 0)
4559 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004560 return rc;
4561}
4562
4563int
Steve French96daf2b2011-05-27 04:34:02 +00004564CIFSFindClose(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004565 const __u16 searchHandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004566{
4567 int rc = 0;
4568 FINDCLOSE_REQ *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004569
Joe Perchesb6b38f72010-04-21 03:50:45 +00004570 cFYI(1, "In CIFSSMBFindClose");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004571 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4572
4573 /* no sense returning error if session restarted
4574 as file handle has been closed */
Steve French790fe572007-07-07 19:25:05 +00004575 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004576 return 0;
4577 if (rc)
4578 return rc;
4579
Linus Torvalds1da177e2005-04-16 15:20:36 -07004580 pSMB->FileID = searchHandle;
4581 pSMB->ByteCount = 0;
Steve French133672e2007-11-13 22:41:37 +00004582 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00004583 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00004584 cERROR(1, "Send error in FindClose = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00004585
Steve Frencha4544342005-08-24 13:59:35 -07004586 cifs_stats_inc(&tcon->num_fclose);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004587
4588 /* Since session is dead, search handle closed on server already */
4589 if (rc == -EAGAIN)
4590 rc = 0;
4591
4592 return rc;
4593}
4594
Linus Torvalds1da177e2005-04-16 15:20:36 -07004595int
Steve French96daf2b2011-05-27 04:34:02 +00004596CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004597 const unsigned char *searchName,
Steve Frenchad7a2922008-02-07 23:25:02 +00004598 __u64 *inode_number,
Steve French50c2f752007-07-13 00:33:32 +00004599 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600{
4601 int rc = 0;
4602 TRANSACTION2_QPI_REQ *pSMB = NULL;
4603 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4604 int name_len, bytes_returned;
4605 __u16 params, byte_count;
4606
Joe Perchesb6b38f72010-04-21 03:50:45 +00004607 cFYI(1, "In GetSrvInodeNum for %s", searchName);
Steve French790fe572007-07-07 19:25:05 +00004608 if (tcon == NULL)
Steve French50c2f752007-07-13 00:33:32 +00004609 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004610
4611GetInodeNumberRetry:
4612 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00004613 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004614 if (rc)
4615 return rc;
4616
Linus Torvalds1da177e2005-04-16 15:20:36 -07004617 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4618 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05004619 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French50c2f752007-07-13 00:33:32 +00004620 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004621 name_len++; /* trailing null */
4622 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004623 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004624 name_len = strnlen(searchName, PATH_MAX);
4625 name_len++; /* trailing null */
4626 strncpy(pSMB->FileName, searchName, name_len);
4627 }
4628
4629 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4630 pSMB->TotalDataCount = 0;
4631 pSMB->MaxParameterCount = cpu_to_le16(2);
4632 /* BB find exact max data count below from sess structure BB */
4633 pSMB->MaxDataCount = cpu_to_le16(4000);
4634 pSMB->MaxSetupCount = 0;
4635 pSMB->Reserved = 0;
4636 pSMB->Flags = 0;
4637 pSMB->Timeout = 0;
4638 pSMB->Reserved2 = 0;
4639 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004640 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004641 pSMB->DataCount = 0;
4642 pSMB->DataOffset = 0;
4643 pSMB->SetupCount = 1;
4644 pSMB->Reserved3 = 0;
4645 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4646 byte_count = params + 1 /* pad */ ;
4647 pSMB->TotalParameterCount = cpu_to_le16(params);
4648 pSMB->ParameterCount = pSMB->TotalParameterCount;
4649 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4650 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004651 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004652 pSMB->ByteCount = cpu_to_le16(byte_count);
4653
4654 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4655 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4656 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004657 cFYI(1, "error %d in QueryInternalInfo", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004658 } else {
4659 /* decode response */
4660 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004661 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04004662 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004663 /* If rc should we check for EOPNOSUPP and
4664 disable the srvino flag? or in caller? */
4665 rc = -EIO; /* bad smb */
Steve French50c2f752007-07-13 00:33:32 +00004666 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004667 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4668 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French50c2f752007-07-13 00:33:32 +00004669 struct file_internal_info *pfinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004670 /* BB Do we need a cast or hash here ? */
Steve French790fe572007-07-07 19:25:05 +00004671 if (count < 8) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004672 cFYI(1, "Illegal size ret in QryIntrnlInf");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673 rc = -EIO;
4674 goto GetInodeNumOut;
4675 }
4676 pfinfo = (struct file_internal_info *)
4677 (data_offset + (char *) &pSMBr->hdr.Protocol);
Steve French85a6dac2009-04-01 05:22:00 +00004678 *inode_number = le64_to_cpu(pfinfo->UniqueId);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004679 }
4680 }
4681GetInodeNumOut:
4682 cifs_buf_release(pSMB);
4683 if (rc == -EAGAIN)
4684 goto GetInodeNumberRetry;
4685 return rc;
4686}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004687
Igor Mammedovfec45852008-05-16 13:06:30 +04004688/* parses DFS refferal V3 structure
4689 * caller is responsible for freeing target_nodes
4690 * returns:
4691 * on success - 0
4692 * on failure - errno
4693 */
4694static int
Steve Frencha1fe78f2008-05-16 18:48:38 +00004695parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
Igor Mammedovfec45852008-05-16 13:06:30 +04004696 unsigned int *num_of_nodes,
4697 struct dfs_info3_param **target_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004698 const struct nls_table *nls_codepage, int remap,
4699 const char *searchName)
Igor Mammedovfec45852008-05-16 13:06:30 +04004700{
4701 int i, rc = 0;
4702 char *data_end;
4703 bool is_unicode;
4704 struct dfs_referral_level_3 *ref;
4705
Harvey Harrison5ca33c62008-07-23 17:45:58 -07004706 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4707 is_unicode = true;
4708 else
4709 is_unicode = false;
Igor Mammedovfec45852008-05-16 13:06:30 +04004710 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4711
4712 if (*num_of_nodes < 1) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004713 cERROR(1, "num_referrals: must be at least > 0,"
4714 "but we get num_referrals = %d\n", *num_of_nodes);
Igor Mammedovfec45852008-05-16 13:06:30 +04004715 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004716 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004717 }
4718
4719 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
Al Viro1d92cfd2008-06-02 10:59:02 +01004720 if (ref->VersionNumber != cpu_to_le16(3)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004721 cERROR(1, "Referrals of V%d version are not supported,"
4722 "should be V3", le16_to_cpu(ref->VersionNumber));
Igor Mammedovfec45852008-05-16 13:06:30 +04004723 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004724 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004725 }
4726
4727 /* get the upper boundary of the resp buffer */
4728 data_end = (char *)(&(pSMBr->PathConsumed)) +
4729 le16_to_cpu(pSMBr->t2.DataCount);
4730
Steve Frenchf19159d2010-04-21 04:12:10 +00004731 cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
Igor Mammedovfec45852008-05-16 13:06:30 +04004732 *num_of_nodes,
Joe Perchesb6b38f72010-04-21 03:50:45 +00004733 le32_to_cpu(pSMBr->DFSFlags));
Igor Mammedovfec45852008-05-16 13:06:30 +04004734
4735 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
4736 *num_of_nodes, GFP_KERNEL);
4737 if (*target_nodes == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004738 cERROR(1, "Failed to allocate buffer for target_nodes\n");
Igor Mammedovfec45852008-05-16 13:06:30 +04004739 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004740 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004741 }
4742
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08004743 /* collect necessary data from referrals */
Igor Mammedovfec45852008-05-16 13:06:30 +04004744 for (i = 0; i < *num_of_nodes; i++) {
4745 char *temp;
4746 int max_len;
4747 struct dfs_info3_param *node = (*target_nodes)+i;
4748
Steve French0e0d2cf2009-05-01 05:27:32 +00004749 node->flags = le32_to_cpu(pSMBr->DFSFlags);
Igor Mammedov2c556082008-10-23 13:58:42 +04004750 if (is_unicode) {
Jeff Layton331c3132008-12-17 06:31:53 -05004751 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4752 GFP_KERNEL);
Steve French2920ee22009-08-31 15:27:26 +00004753 if (tmp == NULL) {
4754 rc = -ENOMEM;
4755 goto parse_DFS_referrals_exit;
4756 }
Igor Mammedov2c556082008-10-23 13:58:42 +04004757 cifsConvertToUCS((__le16 *) tmp, searchName,
4758 PATH_MAX, nls_codepage, remap);
Jeff Layton69f801f2009-04-30 06:46:32 -04004759 node->path_consumed = cifs_ucs2_bytes(tmp,
4760 le16_to_cpu(pSMBr->PathConsumed),
Igor Mammedov2c556082008-10-23 13:58:42 +04004761 nls_codepage);
4762 kfree(tmp);
4763 } else
4764 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4765
Igor Mammedovfec45852008-05-16 13:06:30 +04004766 node->server_type = le16_to_cpu(ref->ServerType);
4767 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4768
4769 /* copy DfsPath */
4770 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4771 max_len = data_end - temp;
Steve Frenchd185cda2009-04-30 17:45:10 +00004772 node->path_name = cifs_strndup_from_ucs(temp, max_len,
4773 is_unicode, nls_codepage);
Jeff Laytond8e2f532009-05-14 07:46:59 -04004774 if (!node->path_name) {
4775 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004776 goto parse_DFS_referrals_exit;
Jeff Layton066ce682009-04-30 07:16:14 -04004777 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004778
4779 /* copy link target UNC */
4780 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4781 max_len = data_end - temp;
Steve Frenchd185cda2009-04-30 17:45:10 +00004782 node->node_name = cifs_strndup_from_ucs(temp, max_len,
4783 is_unicode, nls_codepage);
Jeff Laytond8e2f532009-05-14 07:46:59 -04004784 if (!node->node_name)
4785 rc = -ENOMEM;
Igor Mammedovfec45852008-05-16 13:06:30 +04004786 }
4787
Steve Frencha1fe78f2008-05-16 18:48:38 +00004788parse_DFS_referrals_exit:
Igor Mammedovfec45852008-05-16 13:06:30 +04004789 if (rc) {
4790 free_dfs_info_array(*target_nodes, *num_of_nodes);
4791 *target_nodes = NULL;
4792 *num_of_nodes = 0;
4793 }
4794 return rc;
4795}
4796
Linus Torvalds1da177e2005-04-16 15:20:36 -07004797int
Steve French96daf2b2011-05-27 04:34:02 +00004798CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004799 const unsigned char *searchName,
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004800 struct dfs_info3_param **target_nodes,
4801 unsigned int *num_of_nodes,
Steve French737b7582005-04-28 22:41:06 -07004802 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004803{
4804/* TRANS2_GET_DFS_REFERRAL */
4805 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4806 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004807 int rc = 0;
4808 int bytes_returned;
4809 int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004810 __u16 params, byte_count;
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004811 *num_of_nodes = 0;
4812 *target_nodes = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004813
Joe Perchesb6b38f72010-04-21 03:50:45 +00004814 cFYI(1, "In GetDFSRefer the path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004815 if (ses == NULL)
4816 return -ENODEV;
4817getDFSRetry:
4818 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4819 (void **) &pSMBr);
4820 if (rc)
4821 return rc;
Steve French50c2f752007-07-13 00:33:32 +00004822
4823 /* server pointer checked in called function,
Steve French1982c342005-08-17 12:38:22 -07004824 but should never be null here anyway */
4825 pSMB->hdr.Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004826 pSMB->hdr.Tid = ses->ipc_tid;
4827 pSMB->hdr.Uid = ses->Suid;
Steve French26f57362007-08-30 22:09:15 +00004828 if (ses->capabilities & CAP_STATUS32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004829 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
Steve French26f57362007-08-30 22:09:15 +00004830 if (ses->capabilities & CAP_DFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004831 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004832
4833 if (ses->capabilities & CAP_UNICODE) {
4834 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4835 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05004836 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
Steve French737b7582005-04-28 22:41:06 -07004837 searchName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004838 name_len++; /* trailing null */
4839 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004840 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004841 name_len = strnlen(searchName, PATH_MAX);
4842 name_len++; /* trailing null */
4843 strncpy(pSMB->RequestFileName, searchName, name_len);
4844 }
4845
Steve French790fe572007-07-07 19:25:05 +00004846 if (ses->server) {
Steve French96daf2b2011-05-27 04:34:02 +00004847 if (ses->server->sec_mode &
Steve French1a4e15a2006-10-12 21:33:51 +00004848 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4849 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4850 }
4851
Steve French50c2f752007-07-13 00:33:32 +00004852 pSMB->hdr.Uid = ses->Suid;
Steve French1a4e15a2006-10-12 21:33:51 +00004853
Linus Torvalds1da177e2005-04-16 15:20:36 -07004854 params = 2 /* level */ + name_len /*includes null */ ;
4855 pSMB->TotalDataCount = 0;
4856 pSMB->DataCount = 0;
4857 pSMB->DataOffset = 0;
4858 pSMB->MaxParameterCount = 0;
Steve French582d21e2008-05-13 04:54:12 +00004859 /* BB find exact max SMB PDU from sess structure BB */
4860 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004861 pSMB->MaxSetupCount = 0;
4862 pSMB->Reserved = 0;
4863 pSMB->Flags = 0;
4864 pSMB->Timeout = 0;
4865 pSMB->Reserved2 = 0;
4866 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004867 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004868 pSMB->SetupCount = 1;
4869 pSMB->Reserved3 = 0;
4870 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4871 byte_count = params + 3 /* pad */ ;
4872 pSMB->ParameterCount = cpu_to_le16(params);
4873 pSMB->TotalParameterCount = pSMB->ParameterCount;
4874 pSMB->MaxReferralLevel = cpu_to_le16(3);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004875 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004876 pSMB->ByteCount = cpu_to_le16(byte_count);
4877
4878 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4879 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4880 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004881 cFYI(1, "Send error in GetDFSRefer = %d", rc);
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004882 goto GetDFSRefExit;
4883 }
4884 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004885
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004886 /* BB Also check if enough total bytes returned? */
Jeff Layton820a8032011-05-04 08:05:26 -04004887 if (rc || get_bcc(&pSMBr->hdr) < 17) {
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004888 rc = -EIO; /* bad smb */
Igor Mammedovfec45852008-05-16 13:06:30 +04004889 goto GetDFSRefExit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004890 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004891
Joe Perchesb6b38f72010-04-21 03:50:45 +00004892 cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
Jeff Layton820a8032011-05-04 08:05:26 -04004893 get_bcc(&pSMBr->hdr),
Joe Perchesb6b38f72010-04-21 03:50:45 +00004894 le16_to_cpu(pSMBr->t2.DataOffset));
Igor Mammedovfec45852008-05-16 13:06:30 +04004895
4896 /* parse returned result into more usable form */
Steve Frencha1fe78f2008-05-16 18:48:38 +00004897 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004898 target_nodes, nls_codepage, remap,
4899 searchName);
Igor Mammedovfec45852008-05-16 13:06:30 +04004900
Linus Torvalds1da177e2005-04-16 15:20:36 -07004901GetDFSRefExit:
Steve French0d817bc2008-05-22 02:02:03 +00004902 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004903
4904 if (rc == -EAGAIN)
4905 goto getDFSRetry;
4906
4907 return rc;
4908}
4909
Steve French20962432005-09-21 22:05:57 -07004910/* Query File System Info such as free space to old servers such as Win 9x */
4911int
Steve French96daf2b2011-05-27 04:34:02 +00004912SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
Steve French20962432005-09-21 22:05:57 -07004913{
4914/* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4915 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4916 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4917 FILE_SYSTEM_ALLOC_INFO *response_data;
4918 int rc = 0;
4919 int bytes_returned = 0;
4920 __u16 params, byte_count;
4921
Joe Perchesb6b38f72010-04-21 03:50:45 +00004922 cFYI(1, "OldQFSInfo");
Steve French20962432005-09-21 22:05:57 -07004923oldQFSInfoRetry:
4924 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4925 (void **) &pSMBr);
4926 if (rc)
4927 return rc;
Steve French20962432005-09-21 22:05:57 -07004928
4929 params = 2; /* level */
4930 pSMB->TotalDataCount = 0;
4931 pSMB->MaxParameterCount = cpu_to_le16(2);
4932 pSMB->MaxDataCount = cpu_to_le16(1000);
4933 pSMB->MaxSetupCount = 0;
4934 pSMB->Reserved = 0;
4935 pSMB->Flags = 0;
4936 pSMB->Timeout = 0;
4937 pSMB->Reserved2 = 0;
4938 byte_count = params + 1 /* pad */ ;
4939 pSMB->TotalParameterCount = cpu_to_le16(params);
4940 pSMB->ParameterCount = pSMB->TotalParameterCount;
4941 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4942 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4943 pSMB->DataCount = 0;
4944 pSMB->DataOffset = 0;
4945 pSMB->SetupCount = 1;
4946 pSMB->Reserved3 = 0;
4947 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4948 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004949 inc_rfc1001_len(pSMB, byte_count);
Steve French20962432005-09-21 22:05:57 -07004950 pSMB->ByteCount = cpu_to_le16(byte_count);
4951
4952 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4953 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4954 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004955 cFYI(1, "Send error in QFSInfo = %d", rc);
Steve French20962432005-09-21 22:05:57 -07004956 } else { /* decode response */
4957 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4958
Jeff Layton820a8032011-05-04 08:05:26 -04004959 if (rc || get_bcc(&pSMBr->hdr) < 18)
Steve French20962432005-09-21 22:05:57 -07004960 rc = -EIO; /* bad smb */
4961 else {
4962 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Joe Perchesb6b38f72010-04-21 03:50:45 +00004963 cFYI(1, "qfsinf resp BCC: %d Offset %d",
Jeff Layton820a8032011-05-04 08:05:26 -04004964 get_bcc(&pSMBr->hdr), data_offset);
Steve French20962432005-09-21 22:05:57 -07004965
Steve French50c2f752007-07-13 00:33:32 +00004966 response_data = (FILE_SYSTEM_ALLOC_INFO *)
Steve French20962432005-09-21 22:05:57 -07004967 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4968 FSData->f_bsize =
4969 le16_to_cpu(response_data->BytesPerSector) *
4970 le32_to_cpu(response_data->
4971 SectorsPerAllocationUnit);
4972 FSData->f_blocks =
Steve French50c2f752007-07-13 00:33:32 +00004973 le32_to_cpu(response_data->TotalAllocationUnits);
Steve French20962432005-09-21 22:05:57 -07004974 FSData->f_bfree = FSData->f_bavail =
4975 le32_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesb6b38f72010-04-21 03:50:45 +00004976 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
4977 (unsigned long long)FSData->f_blocks,
4978 (unsigned long long)FSData->f_bfree,
4979 FSData->f_bsize);
Steve French20962432005-09-21 22:05:57 -07004980 }
4981 }
4982 cifs_buf_release(pSMB);
4983
4984 if (rc == -EAGAIN)
4985 goto oldQFSInfoRetry;
4986
4987 return rc;
4988}
4989
Linus Torvalds1da177e2005-04-16 15:20:36 -07004990int
Steve French96daf2b2011-05-27 04:34:02 +00004991CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004992{
4993/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4994 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4995 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4996 FILE_SYSTEM_INFO *response_data;
4997 int rc = 0;
4998 int bytes_returned = 0;
4999 __u16 params, byte_count;
5000
Joe Perchesb6b38f72010-04-21 03:50:45 +00005001 cFYI(1, "In QFSInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005002QFSInfoRetry:
5003 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5004 (void **) &pSMBr);
5005 if (rc)
5006 return rc;
5007
5008 params = 2; /* level */
5009 pSMB->TotalDataCount = 0;
5010 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French20962432005-09-21 22:05:57 -07005011 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005012 pSMB->MaxSetupCount = 0;
5013 pSMB->Reserved = 0;
5014 pSMB->Flags = 0;
5015 pSMB->Timeout = 0;
5016 pSMB->Reserved2 = 0;
5017 byte_count = params + 1 /* pad */ ;
5018 pSMB->TotalParameterCount = cpu_to_le16(params);
5019 pSMB->ParameterCount = pSMB->TotalParameterCount;
5020 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005021 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005022 pSMB->DataCount = 0;
5023 pSMB->DataOffset = 0;
5024 pSMB->SetupCount = 1;
5025 pSMB->Reserved3 = 0;
5026 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5027 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005028 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005029 pSMB->ByteCount = cpu_to_le16(byte_count);
5030
5031 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5032 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5033 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005034 cFYI(1, "Send error in QFSInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005035 } else { /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00005036 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005037
Jeff Layton820a8032011-05-04 08:05:26 -04005038 if (rc || get_bcc(&pSMBr->hdr) < 24)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005039 rc = -EIO; /* bad smb */
5040 else {
5041 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005042
5043 response_data =
5044 (FILE_SYSTEM_INFO
5045 *) (((char *) &pSMBr->hdr.Protocol) +
5046 data_offset);
5047 FSData->f_bsize =
5048 le32_to_cpu(response_data->BytesPerSector) *
5049 le32_to_cpu(response_data->
5050 SectorsPerAllocationUnit);
5051 FSData->f_blocks =
5052 le64_to_cpu(response_data->TotalAllocationUnits);
5053 FSData->f_bfree = FSData->f_bavail =
5054 le64_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesb6b38f72010-04-21 03:50:45 +00005055 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5056 (unsigned long long)FSData->f_blocks,
5057 (unsigned long long)FSData->f_bfree,
5058 FSData->f_bsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005059 }
5060 }
5061 cifs_buf_release(pSMB);
5062
5063 if (rc == -EAGAIN)
5064 goto QFSInfoRetry;
5065
5066 return rc;
5067}
5068
5069int
Steve French96daf2b2011-05-27 04:34:02 +00005070CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005071{
5072/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5073 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5074 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5075 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5076 int rc = 0;
5077 int bytes_returned = 0;
5078 __u16 params, byte_count;
5079
Joe Perchesb6b38f72010-04-21 03:50:45 +00005080 cFYI(1, "In QFSAttributeInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005081QFSAttributeRetry:
5082 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5083 (void **) &pSMBr);
5084 if (rc)
5085 return rc;
5086
5087 params = 2; /* level */
5088 pSMB->TotalDataCount = 0;
5089 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005090 /* BB find exact max SMB PDU from sess structure BB */
5091 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005092 pSMB->MaxSetupCount = 0;
5093 pSMB->Reserved = 0;
5094 pSMB->Flags = 0;
5095 pSMB->Timeout = 0;
5096 pSMB->Reserved2 = 0;
5097 byte_count = params + 1 /* pad */ ;
5098 pSMB->TotalParameterCount = cpu_to_le16(params);
5099 pSMB->ParameterCount = pSMB->TotalParameterCount;
5100 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005101 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005102 pSMB->DataCount = 0;
5103 pSMB->DataOffset = 0;
5104 pSMB->SetupCount = 1;
5105 pSMB->Reserved3 = 0;
5106 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5107 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005108 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005109 pSMB->ByteCount = cpu_to_le16(byte_count);
5110
5111 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5112 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5113 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005114 cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005115 } else { /* decode response */
5116 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5117
Jeff Layton820a8032011-05-04 08:05:26 -04005118 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Steve French50c2f752007-07-13 00:33:32 +00005119 /* BB also check if enough bytes returned */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005120 rc = -EIO; /* bad smb */
5121 } else {
5122 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5123 response_data =
5124 (FILE_SYSTEM_ATTRIBUTE_INFO
5125 *) (((char *) &pSMBr->hdr.Protocol) +
5126 data_offset);
5127 memcpy(&tcon->fsAttrInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005128 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005129 }
5130 }
5131 cifs_buf_release(pSMB);
5132
5133 if (rc == -EAGAIN)
5134 goto QFSAttributeRetry;
5135
5136 return rc;
5137}
5138
5139int
Steve French96daf2b2011-05-27 04:34:02 +00005140CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005141{
5142/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5143 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5144 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5145 FILE_SYSTEM_DEVICE_INFO *response_data;
5146 int rc = 0;
5147 int bytes_returned = 0;
5148 __u16 params, byte_count;
5149
Joe Perchesb6b38f72010-04-21 03:50:45 +00005150 cFYI(1, "In QFSDeviceInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005151QFSDeviceRetry:
5152 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5153 (void **) &pSMBr);
5154 if (rc)
5155 return rc;
5156
5157 params = 2; /* level */
5158 pSMB->TotalDataCount = 0;
5159 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005160 /* BB find exact max SMB PDU from sess structure BB */
5161 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005162 pSMB->MaxSetupCount = 0;
5163 pSMB->Reserved = 0;
5164 pSMB->Flags = 0;
5165 pSMB->Timeout = 0;
5166 pSMB->Reserved2 = 0;
5167 byte_count = params + 1 /* pad */ ;
5168 pSMB->TotalParameterCount = cpu_to_le16(params);
5169 pSMB->ParameterCount = pSMB->TotalParameterCount;
5170 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005171 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005172
5173 pSMB->DataCount = 0;
5174 pSMB->DataOffset = 0;
5175 pSMB->SetupCount = 1;
5176 pSMB->Reserved3 = 0;
5177 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5178 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005179 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005180 pSMB->ByteCount = cpu_to_le16(byte_count);
5181
5182 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5183 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5184 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005185 cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005186 } else { /* decode response */
5187 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5188
Jeff Layton820a8032011-05-04 08:05:26 -04005189 if (rc || get_bcc(&pSMBr->hdr) <
5190 sizeof(FILE_SYSTEM_DEVICE_INFO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005191 rc = -EIO; /* bad smb */
5192 else {
5193 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5194 response_data =
Steve French737b7582005-04-28 22:41:06 -07005195 (FILE_SYSTEM_DEVICE_INFO *)
5196 (((char *) &pSMBr->hdr.Protocol) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07005197 data_offset);
5198 memcpy(&tcon->fsDevInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005199 sizeof(FILE_SYSTEM_DEVICE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005200 }
5201 }
5202 cifs_buf_release(pSMB);
5203
5204 if (rc == -EAGAIN)
5205 goto QFSDeviceRetry;
5206
5207 return rc;
5208}
5209
5210int
Steve French96daf2b2011-05-27 04:34:02 +00005211CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005212{
5213/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5214 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5215 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5216 FILE_SYSTEM_UNIX_INFO *response_data;
5217 int rc = 0;
5218 int bytes_returned = 0;
5219 __u16 params, byte_count;
5220
Joe Perchesb6b38f72010-04-21 03:50:45 +00005221 cFYI(1, "In QFSUnixInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005222QFSUnixRetry:
Jeff Laytonf5695992010-09-29 15:27:08 -04005223 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5224 (void **) &pSMB, (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005225 if (rc)
5226 return rc;
5227
5228 params = 2; /* level */
5229 pSMB->TotalDataCount = 0;
5230 pSMB->DataCount = 0;
5231 pSMB->DataOffset = 0;
5232 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005233 /* BB find exact max SMB PDU from sess structure BB */
5234 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005235 pSMB->MaxSetupCount = 0;
5236 pSMB->Reserved = 0;
5237 pSMB->Flags = 0;
5238 pSMB->Timeout = 0;
5239 pSMB->Reserved2 = 0;
5240 byte_count = params + 1 /* pad */ ;
5241 pSMB->ParameterCount = cpu_to_le16(params);
5242 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005243 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5244 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005245 pSMB->SetupCount = 1;
5246 pSMB->Reserved3 = 0;
5247 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5248 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005249 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005250 pSMB->ByteCount = cpu_to_le16(byte_count);
5251
5252 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5253 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5254 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005255 cERROR(1, "Send error in QFSUnixInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005256 } else { /* decode response */
5257 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5258
Jeff Layton820a8032011-05-04 08:05:26 -04005259 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005260 rc = -EIO; /* bad smb */
5261 } else {
5262 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5263 response_data =
5264 (FILE_SYSTEM_UNIX_INFO
5265 *) (((char *) &pSMBr->hdr.Protocol) +
5266 data_offset);
5267 memcpy(&tcon->fsUnixInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005268 sizeof(FILE_SYSTEM_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005269 }
5270 }
5271 cifs_buf_release(pSMB);
5272
5273 if (rc == -EAGAIN)
5274 goto QFSUnixRetry;
5275
5276
5277 return rc;
5278}
5279
Jeremy Allisonac670552005-06-22 17:26:35 -07005280int
Steve French96daf2b2011-05-27 04:34:02 +00005281CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
Jeremy Allisonac670552005-06-22 17:26:35 -07005282{
5283/* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5284 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5285 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5286 int rc = 0;
5287 int bytes_returned = 0;
5288 __u16 params, param_offset, offset, byte_count;
5289
Joe Perchesb6b38f72010-04-21 03:50:45 +00005290 cFYI(1, "In SETFSUnixInfo");
Jeremy Allisonac670552005-06-22 17:26:35 -07005291SETFSUnixRetry:
Steve Frenchf26282c2006-03-01 09:17:37 +00005292 /* BB switch to small buf init to save memory */
Jeff Laytonf5695992010-09-29 15:27:08 -04005293 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5294 (void **) &pSMB, (void **) &pSMBr);
Jeremy Allisonac670552005-06-22 17:26:35 -07005295 if (rc)
5296 return rc;
5297
5298 params = 4; /* 2 bytes zero followed by info level. */
5299 pSMB->MaxSetupCount = 0;
5300 pSMB->Reserved = 0;
5301 pSMB->Flags = 0;
5302 pSMB->Timeout = 0;
5303 pSMB->Reserved2 = 0;
Steve French50c2f752007-07-13 00:33:32 +00005304 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5305 - 4;
Jeremy Allisonac670552005-06-22 17:26:35 -07005306 offset = param_offset + params;
5307
5308 pSMB->MaxParameterCount = cpu_to_le16(4);
Steve French582d21e2008-05-13 04:54:12 +00005309 /* BB find exact max SMB PDU from sess structure BB */
5310 pSMB->MaxDataCount = cpu_to_le16(100);
Jeremy Allisonac670552005-06-22 17:26:35 -07005311 pSMB->SetupCount = 1;
5312 pSMB->Reserved3 = 0;
5313 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5314 byte_count = 1 /* pad */ + params + 12;
5315
5316 pSMB->DataCount = cpu_to_le16(12);
5317 pSMB->ParameterCount = cpu_to_le16(params);
5318 pSMB->TotalDataCount = pSMB->DataCount;
5319 pSMB->TotalParameterCount = pSMB->ParameterCount;
5320 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5321 pSMB->DataOffset = cpu_to_le16(offset);
5322
5323 /* Params. */
5324 pSMB->FileNum = 0;
5325 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5326
5327 /* Data. */
5328 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5329 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5330 pSMB->ClientUnixCap = cpu_to_le64(cap);
5331
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005332 inc_rfc1001_len(pSMB, byte_count);
Jeremy Allisonac670552005-06-22 17:26:35 -07005333 pSMB->ByteCount = cpu_to_le16(byte_count);
5334
5335 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5336 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5337 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005338 cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
Jeremy Allisonac670552005-06-22 17:26:35 -07005339 } else { /* decode response */
5340 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve Frenchad7a2922008-02-07 23:25:02 +00005341 if (rc)
Jeremy Allisonac670552005-06-22 17:26:35 -07005342 rc = -EIO; /* bad smb */
Jeremy Allisonac670552005-06-22 17:26:35 -07005343 }
5344 cifs_buf_release(pSMB);
5345
5346 if (rc == -EAGAIN)
5347 goto SETFSUnixRetry;
5348
5349 return rc;
5350}
5351
5352
Linus Torvalds1da177e2005-04-16 15:20:36 -07005353
5354int
Steve French96daf2b2011-05-27 04:34:02 +00005355CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
Steve French737b7582005-04-28 22:41:06 -07005356 struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005357{
5358/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5359 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5360 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5361 FILE_SYSTEM_POSIX_INFO *response_data;
5362 int rc = 0;
5363 int bytes_returned = 0;
5364 __u16 params, byte_count;
5365
Joe Perchesb6b38f72010-04-21 03:50:45 +00005366 cFYI(1, "In QFSPosixInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005367QFSPosixRetry:
5368 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5369 (void **) &pSMBr);
5370 if (rc)
5371 return rc;
5372
5373 params = 2; /* level */
5374 pSMB->TotalDataCount = 0;
5375 pSMB->DataCount = 0;
5376 pSMB->DataOffset = 0;
5377 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005378 /* BB find exact max SMB PDU from sess structure BB */
5379 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005380 pSMB->MaxSetupCount = 0;
5381 pSMB->Reserved = 0;
5382 pSMB->Flags = 0;
5383 pSMB->Timeout = 0;
5384 pSMB->Reserved2 = 0;
5385 byte_count = params + 1 /* pad */ ;
5386 pSMB->ParameterCount = cpu_to_le16(params);
5387 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005388 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5389 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005390 pSMB->SetupCount = 1;
5391 pSMB->Reserved3 = 0;
5392 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5393 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005394 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005395 pSMB->ByteCount = cpu_to_le16(byte_count);
5396
5397 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5398 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5399 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005400 cFYI(1, "Send error in QFSUnixInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005401 } else { /* decode response */
5402 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5403
Jeff Layton820a8032011-05-04 08:05:26 -04005404 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005405 rc = -EIO; /* bad smb */
5406 } else {
5407 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5408 response_data =
5409 (FILE_SYSTEM_POSIX_INFO
5410 *) (((char *) &pSMBr->hdr.Protocol) +
5411 data_offset);
5412 FSData->f_bsize =
5413 le32_to_cpu(response_data->BlockSize);
5414 FSData->f_blocks =
5415 le64_to_cpu(response_data->TotalBlocks);
5416 FSData->f_bfree =
5417 le64_to_cpu(response_data->BlocksAvail);
Steve French790fe572007-07-07 19:25:05 +00005418 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005419 FSData->f_bavail = FSData->f_bfree;
5420 } else {
5421 FSData->f_bavail =
Steve French50c2f752007-07-13 00:33:32 +00005422 le64_to_cpu(response_data->UserBlocksAvail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005423 }
Steve French790fe572007-07-07 19:25:05 +00005424 if (response_data->TotalFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005425 FSData->f_files =
Steve French50c2f752007-07-13 00:33:32 +00005426 le64_to_cpu(response_data->TotalFileNodes);
Steve French790fe572007-07-07 19:25:05 +00005427 if (response_data->FreeFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005428 FSData->f_ffree =
Steve French50c2f752007-07-13 00:33:32 +00005429 le64_to_cpu(response_data->FreeFileNodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005430 }
5431 }
5432 cifs_buf_release(pSMB);
5433
5434 if (rc == -EAGAIN)
5435 goto QFSPosixRetry;
5436
5437 return rc;
5438}
5439
5440
Steve French50c2f752007-07-13 00:33:32 +00005441/* We can not use write of zero bytes trick to
5442 set file size due to need for large file support. Also note that
5443 this SetPathInfo is preferred to SetFileInfo based method in next
Linus Torvalds1da177e2005-04-16 15:20:36 -07005444 routine which is only needed to work around a sharing violation bug
5445 in Samba which this routine can run into */
5446
5447int
Steve French96daf2b2011-05-27 04:34:02 +00005448CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French4b18f2a2008-04-29 00:06:05 +00005449 __u64 size, bool SetAllocation,
Steve French737b7582005-04-28 22:41:06 -07005450 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005451{
5452 struct smb_com_transaction2_spi_req *pSMB = NULL;
5453 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5454 struct file_end_of_file_info *parm_data;
5455 int name_len;
5456 int rc = 0;
5457 int bytes_returned = 0;
5458 __u16 params, byte_count, data_count, param_offset, offset;
5459
Joe Perchesb6b38f72010-04-21 03:50:45 +00005460 cFYI(1, "In SetEOF");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005461SetEOFRetry:
5462 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5463 (void **) &pSMBr);
5464 if (rc)
5465 return rc;
5466
5467 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5468 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05005469 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
Steve French737b7582005-04-28 22:41:06 -07005470 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005471 name_len++; /* trailing null */
5472 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07005473 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005474 name_len = strnlen(fileName, PATH_MAX);
5475 name_len++; /* trailing null */
5476 strncpy(pSMB->FileName, fileName, name_len);
5477 }
5478 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005479 data_count = sizeof(struct file_end_of_file_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005480 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French3e87d802005-09-18 20:49:21 -07005481 pSMB->MaxDataCount = cpu_to_le16(4100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005482 pSMB->MaxSetupCount = 0;
5483 pSMB->Reserved = 0;
5484 pSMB->Flags = 0;
5485 pSMB->Timeout = 0;
5486 pSMB->Reserved2 = 0;
5487 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005488 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005489 offset = param_offset + params;
Steve French790fe572007-07-07 19:25:05 +00005490 if (SetAllocation) {
Steve French50c2f752007-07-13 00:33:32 +00005491 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5492 pSMB->InformationLevel =
5493 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5494 else
5495 pSMB->InformationLevel =
5496 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5497 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005498 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5499 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005500 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005501 else
5502 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005503 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005504 }
5505
5506 parm_data =
5507 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5508 offset);
5509 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5510 pSMB->DataOffset = cpu_to_le16(offset);
5511 pSMB->SetupCount = 1;
5512 pSMB->Reserved3 = 0;
5513 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5514 byte_count = 3 /* pad */ + params + data_count;
5515 pSMB->DataCount = cpu_to_le16(data_count);
5516 pSMB->TotalDataCount = pSMB->DataCount;
5517 pSMB->ParameterCount = cpu_to_le16(params);
5518 pSMB->TotalParameterCount = pSMB->ParameterCount;
5519 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005520 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005521 parm_data->FileSize = cpu_to_le64(size);
5522 pSMB->ByteCount = cpu_to_le16(byte_count);
5523 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5524 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005525 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005526 cFYI(1, "SetPathInfo (file size) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005527
5528 cifs_buf_release(pSMB);
5529
5530 if (rc == -EAGAIN)
5531 goto SetEOFRetry;
5532
5533 return rc;
5534}
5535
5536int
Steve French96daf2b2011-05-27 04:34:02 +00005537CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
Steve French4b18f2a2008-04-29 00:06:05 +00005538 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005539{
5540 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005541 struct file_end_of_file_info *parm_data;
5542 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005543 __u16 params, param_offset, offset, byte_count, count;
5544
Joe Perchesb6b38f72010-04-21 03:50:45 +00005545 cFYI(1, "SetFileSize (via SetFileInfo) %lld",
5546 (long long)size);
Steve Frenchcd634992005-04-28 22:41:10 -07005547 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5548
Linus Torvalds1da177e2005-04-16 15:20:36 -07005549 if (rc)
5550 return rc;
5551
5552 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5553 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005554
Linus Torvalds1da177e2005-04-16 15:20:36 -07005555 params = 6;
5556 pSMB->MaxSetupCount = 0;
5557 pSMB->Reserved = 0;
5558 pSMB->Flags = 0;
5559 pSMB->Timeout = 0;
5560 pSMB->Reserved2 = 0;
5561 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5562 offset = param_offset + params;
5563
Linus Torvalds1da177e2005-04-16 15:20:36 -07005564 count = sizeof(struct file_end_of_file_info);
5565 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005566 /* BB find exact max SMB PDU from sess structure BB */
5567 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005568 pSMB->SetupCount = 1;
5569 pSMB->Reserved3 = 0;
5570 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5571 byte_count = 3 /* pad */ + params + count;
5572 pSMB->DataCount = cpu_to_le16(count);
5573 pSMB->ParameterCount = cpu_to_le16(params);
5574 pSMB->TotalDataCount = pSMB->DataCount;
5575 pSMB->TotalParameterCount = pSMB->ParameterCount;
5576 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5577 parm_data =
Steve French50c2f752007-07-13 00:33:32 +00005578 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5579 + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005580 pSMB->DataOffset = cpu_to_le16(offset);
5581 parm_data->FileSize = cpu_to_le64(size);
5582 pSMB->Fid = fid;
Steve French790fe572007-07-07 19:25:05 +00005583 if (SetAllocation) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005584 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5585 pSMB->InformationLevel =
5586 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5587 else
5588 pSMB->InformationLevel =
5589 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
Steve French50c2f752007-07-13 00:33:32 +00005590 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005591 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5592 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005593 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005594 else
5595 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005596 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005597 }
5598 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005599 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005600 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French133672e2007-11-13 22:41:37 +00005601 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005602 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005603 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005604 }
5605
Steve French50c2f752007-07-13 00:33:32 +00005606 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005607 since file handle passed in no longer valid */
5608
5609 return rc;
5610}
5611
Steve French50c2f752007-07-13 00:33:32 +00005612/* Some legacy servers such as NT4 require that the file times be set on
Linus Torvalds1da177e2005-04-16 15:20:36 -07005613 an open handle, rather than by pathname - this is awkward due to
5614 potential access conflicts on the open, but it is unavoidable for these
5615 old servers since the only other choice is to go from 100 nanosecond DCE
5616 time and resort to the original setpathinfo level which takes the ancient
5617 DOS time format with 2 second granularity */
5618int
Steve French96daf2b2011-05-27 04:34:02 +00005619CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005620 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005621{
5622 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005623 char *data_offset;
5624 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005625 __u16 params, param_offset, offset, byte_count, count;
5626
Joe Perchesb6b38f72010-04-21 03:50:45 +00005627 cFYI(1, "Set Times (via SetFileInfo)");
Steve Frenchcd634992005-04-28 22:41:10 -07005628 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5629
Linus Torvalds1da177e2005-04-16 15:20:36 -07005630 if (rc)
5631 return rc;
5632
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005633 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5634 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005635
Linus Torvalds1da177e2005-04-16 15:20:36 -07005636 params = 6;
5637 pSMB->MaxSetupCount = 0;
5638 pSMB->Reserved = 0;
5639 pSMB->Flags = 0;
5640 pSMB->Timeout = 0;
5641 pSMB->Reserved2 = 0;
5642 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5643 offset = param_offset + params;
5644
Steve French50c2f752007-07-13 00:33:32 +00005645 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005646
Steve French26f57362007-08-30 22:09:15 +00005647 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005648 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005649 /* BB find max SMB PDU from sess */
5650 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005651 pSMB->SetupCount = 1;
5652 pSMB->Reserved3 = 0;
5653 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5654 byte_count = 3 /* pad */ + params + count;
5655 pSMB->DataCount = cpu_to_le16(count);
5656 pSMB->ParameterCount = cpu_to_le16(params);
5657 pSMB->TotalDataCount = pSMB->DataCount;
5658 pSMB->TotalParameterCount = pSMB->ParameterCount;
5659 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5660 pSMB->DataOffset = cpu_to_le16(offset);
5661 pSMB->Fid = fid;
5662 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5663 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5664 else
5665 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5666 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005667 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005668 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00005669 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Steve French133672e2007-11-13 22:41:37 +00005670 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005671 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005672 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005673
Steve French50c2f752007-07-13 00:33:32 +00005674 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005675 since file handle passed in no longer valid */
5676
5677 return rc;
5678}
5679
Jeff Layton6d22f092008-09-23 11:48:35 -04005680int
Steve French96daf2b2011-05-27 04:34:02 +00005681CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
Jeff Layton6d22f092008-09-23 11:48:35 -04005682 bool delete_file, __u16 fid, __u32 pid_of_opener)
5683{
5684 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5685 char *data_offset;
5686 int rc = 0;
5687 __u16 params, param_offset, offset, byte_count, count;
5688
Joe Perchesb6b38f72010-04-21 03:50:45 +00005689 cFYI(1, "Set File Disposition (via SetFileInfo)");
Jeff Layton6d22f092008-09-23 11:48:35 -04005690 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5691
5692 if (rc)
5693 return rc;
5694
5695 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5696 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5697
5698 params = 6;
5699 pSMB->MaxSetupCount = 0;
5700 pSMB->Reserved = 0;
5701 pSMB->Flags = 0;
5702 pSMB->Timeout = 0;
5703 pSMB->Reserved2 = 0;
5704 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5705 offset = param_offset + params;
5706
5707 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5708
5709 count = 1;
5710 pSMB->MaxParameterCount = cpu_to_le16(2);
5711 /* BB find max SMB PDU from sess */
5712 pSMB->MaxDataCount = cpu_to_le16(1000);
5713 pSMB->SetupCount = 1;
5714 pSMB->Reserved3 = 0;
5715 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5716 byte_count = 3 /* pad */ + params + count;
5717 pSMB->DataCount = cpu_to_le16(count);
5718 pSMB->ParameterCount = cpu_to_le16(params);
5719 pSMB->TotalDataCount = pSMB->DataCount;
5720 pSMB->TotalParameterCount = pSMB->ParameterCount;
5721 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5722 pSMB->DataOffset = cpu_to_le16(offset);
5723 pSMB->Fid = fid;
5724 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5725 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005726 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton6d22f092008-09-23 11:48:35 -04005727 pSMB->ByteCount = cpu_to_le16(byte_count);
5728 *data_offset = delete_file ? 1 : 0;
5729 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
5730 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005731 cFYI(1, "Send error in SetFileDisposition = %d", rc);
Jeff Layton6d22f092008-09-23 11:48:35 -04005732
5733 return rc;
5734}
Linus Torvalds1da177e2005-04-16 15:20:36 -07005735
5736int
Steve French96daf2b2011-05-27 04:34:02 +00005737CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton6fc000e2008-08-02 07:26:12 -04005738 const char *fileName, const FILE_BASIC_INFO *data,
5739 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740{
5741 TRANSACTION2_SPI_REQ *pSMB = NULL;
5742 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5743 int name_len;
5744 int rc = 0;
5745 int bytes_returned = 0;
5746 char *data_offset;
5747 __u16 params, param_offset, offset, byte_count, count;
5748
Joe Perchesb6b38f72010-04-21 03:50:45 +00005749 cFYI(1, "In SetTimes");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005750
5751SetTimesRetry:
5752 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5753 (void **) &pSMBr);
5754 if (rc)
5755 return rc;
5756
5757 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5758 name_len =
Steve Frenchb1a45692005-05-17 16:07:23 -05005759 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
Steve French737b7582005-04-28 22:41:06 -07005760 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005761 name_len++; /* trailing null */
5762 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005763 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005764 name_len = strnlen(fileName, PATH_MAX);
5765 name_len++; /* trailing null */
5766 strncpy(pSMB->FileName, fileName, name_len);
5767 }
5768
5769 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005770 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005771 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005772 /* BB find max SMB PDU from sess structure BB */
5773 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005774 pSMB->MaxSetupCount = 0;
5775 pSMB->Reserved = 0;
5776 pSMB->Flags = 0;
5777 pSMB->Timeout = 0;
5778 pSMB->Reserved2 = 0;
5779 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005780 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005781 offset = param_offset + params;
5782 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5783 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5784 pSMB->DataOffset = cpu_to_le16(offset);
5785 pSMB->SetupCount = 1;
5786 pSMB->Reserved3 = 0;
5787 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5788 byte_count = 3 /* pad */ + params + count;
5789
5790 pSMB->DataCount = cpu_to_le16(count);
5791 pSMB->ParameterCount = cpu_to_le16(params);
5792 pSMB->TotalDataCount = pSMB->DataCount;
5793 pSMB->TotalParameterCount = pSMB->ParameterCount;
5794 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5795 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5796 else
5797 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5798 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005799 inc_rfc1001_len(pSMB, byte_count);
Steve French26f57362007-08-30 22:09:15 +00005800 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005801 pSMB->ByteCount = cpu_to_le16(byte_count);
5802 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5803 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005804 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005805 cFYI(1, "SetPathInfo (times) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005806
5807 cifs_buf_release(pSMB);
5808
5809 if (rc == -EAGAIN)
5810 goto SetTimesRetry;
5811
5812 return rc;
5813}
5814
5815/* Can not be used to set time stamps yet (due to old DOS time format) */
5816/* Can be used to set attributes */
5817#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5818 handling it anyway and NT4 was what we thought it would be needed for
5819 Do not delete it until we prove whether needed for Win9x though */
5820int
Steve French96daf2b2011-05-27 04:34:02 +00005821CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005822 __u16 dos_attrs, const struct nls_table *nls_codepage)
5823{
5824 SETATTR_REQ *pSMB = NULL;
5825 SETATTR_RSP *pSMBr = NULL;
5826 int rc = 0;
5827 int bytes_returned;
5828 int name_len;
5829
Joe Perchesb6b38f72010-04-21 03:50:45 +00005830 cFYI(1, "In SetAttrLegacy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005831
5832SetAttrLgcyRetry:
5833 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5834 (void **) &pSMBr);
5835 if (rc)
5836 return rc;
5837
5838 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5839 name_len =
Steve French50c2f752007-07-13 00:33:32 +00005840 ConvertToUCS((__le16 *) pSMB->fileName, fileName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005841 PATH_MAX, nls_codepage);
5842 name_len++; /* trailing null */
5843 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005844 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005845 name_len = strnlen(fileName, PATH_MAX);
5846 name_len++; /* trailing null */
5847 strncpy(pSMB->fileName, fileName, name_len);
5848 }
5849 pSMB->attr = cpu_to_le16(dos_attrs);
5850 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005851 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005852 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5853 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5854 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005855 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005856 cFYI(1, "Error in LegacySetAttr = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005857
5858 cifs_buf_release(pSMB);
5859
5860 if (rc == -EAGAIN)
5861 goto SetAttrLgcyRetry;
5862
5863 return rc;
5864}
5865#endif /* temporarily unneeded SetAttr legacy function */
5866
Jeff Layton654cf142009-07-09 20:02:49 -04005867static void
5868cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5869 const struct cifs_unix_set_info_args *args)
5870{
5871 u64 mode = args->mode;
5872
5873 /*
5874 * Samba server ignores set of file size to zero due to bugs in some
5875 * older clients, but we should be precise - we use SetFileSize to
5876 * set file size and do not want to truncate file size to zero
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005877 * accidentally as happened on one Samba server beta by putting
Jeff Layton654cf142009-07-09 20:02:49 -04005878 * zero instead of -1 here
5879 */
5880 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5881 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5882 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5883 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5884 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5885 data_offset->Uid = cpu_to_le64(args->uid);
5886 data_offset->Gid = cpu_to_le64(args->gid);
5887 /* better to leave device as zero when it is */
5888 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5889 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5890 data_offset->Permissions = cpu_to_le64(mode);
5891
5892 if (S_ISREG(mode))
5893 data_offset->Type = cpu_to_le32(UNIX_FILE);
5894 else if (S_ISDIR(mode))
5895 data_offset->Type = cpu_to_le32(UNIX_DIR);
5896 else if (S_ISLNK(mode))
5897 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5898 else if (S_ISCHR(mode))
5899 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5900 else if (S_ISBLK(mode))
5901 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5902 else if (S_ISFIFO(mode))
5903 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5904 else if (S_ISSOCK(mode))
5905 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5906}
5907
Linus Torvalds1da177e2005-04-16 15:20:36 -07005908int
Steve French96daf2b2011-05-27 04:34:02 +00005909CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005910 const struct cifs_unix_set_info_args *args,
5911 u16 fid, u32 pid_of_opener)
5912{
5913 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5914 FILE_UNIX_BASIC_INFO *data_offset;
5915 int rc = 0;
5916 u16 params, param_offset, offset, byte_count, count;
5917
Joe Perchesb6b38f72010-04-21 03:50:45 +00005918 cFYI(1, "Set Unix Info (via SetFileInfo)");
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005919 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5920
5921 if (rc)
5922 return rc;
5923
5924 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5925 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5926
5927 params = 6;
5928 pSMB->MaxSetupCount = 0;
5929 pSMB->Reserved = 0;
5930 pSMB->Flags = 0;
5931 pSMB->Timeout = 0;
5932 pSMB->Reserved2 = 0;
5933 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5934 offset = param_offset + params;
5935
5936 data_offset = (FILE_UNIX_BASIC_INFO *)
5937 ((char *)(&pSMB->hdr.Protocol) + offset);
5938 count = sizeof(FILE_UNIX_BASIC_INFO);
5939
5940 pSMB->MaxParameterCount = cpu_to_le16(2);
5941 /* BB find max SMB PDU from sess */
5942 pSMB->MaxDataCount = cpu_to_le16(1000);
5943 pSMB->SetupCount = 1;
5944 pSMB->Reserved3 = 0;
5945 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5946 byte_count = 3 /* pad */ + params + count;
5947 pSMB->DataCount = cpu_to_le16(count);
5948 pSMB->ParameterCount = cpu_to_le16(params);
5949 pSMB->TotalDataCount = pSMB->DataCount;
5950 pSMB->TotalParameterCount = pSMB->ParameterCount;
5951 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5952 pSMB->DataOffset = cpu_to_le16(offset);
5953 pSMB->Fid = fid;
5954 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5955 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005956 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005957 pSMB->ByteCount = cpu_to_le16(byte_count);
5958
5959 cifs_fill_unix_set_info(data_offset, args);
5960
5961 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
5962 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005963 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005964
5965 /* Note: On -EAGAIN error only caller can retry on handle based calls
5966 since file handle passed in no longer valid */
5967
5968 return rc;
5969}
5970
5971int
Steve French96daf2b2011-05-27 04:34:02 +00005972CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
Jeff Layton01ea95e2009-07-09 20:02:49 -04005973 const struct cifs_unix_set_info_args *args,
5974 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005975{
5976 TRANSACTION2_SPI_REQ *pSMB = NULL;
5977 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5978 int name_len;
5979 int rc = 0;
5980 int bytes_returned = 0;
5981 FILE_UNIX_BASIC_INFO *data_offset;
5982 __u16 params, param_offset, offset, count, byte_count;
5983
Joe Perchesb6b38f72010-04-21 03:50:45 +00005984 cFYI(1, "In SetUID/GID/Mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005985setPermsRetry:
5986 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5987 (void **) &pSMBr);
5988 if (rc)
5989 return rc;
5990
5991 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5992 name_len =
Steve French50c2f752007-07-13 00:33:32 +00005993 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
Steve French737b7582005-04-28 22:41:06 -07005994 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005995 name_len++; /* trailing null */
5996 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07005997 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005998 name_len = strnlen(fileName, PATH_MAX);
5999 name_len++; /* trailing null */
6000 strncpy(pSMB->FileName, fileName, name_len);
6001 }
6002
6003 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00006004 count = sizeof(FILE_UNIX_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006005 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006006 /* BB find max SMB PDU from sess structure BB */
6007 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006008 pSMB->MaxSetupCount = 0;
6009 pSMB->Reserved = 0;
6010 pSMB->Flags = 0;
6011 pSMB->Timeout = 0;
6012 pSMB->Reserved2 = 0;
6013 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006014 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006015 offset = param_offset + params;
6016 data_offset =
6017 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6018 offset);
6019 memset(data_offset, 0, count);
6020 pSMB->DataOffset = cpu_to_le16(offset);
6021 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6022 pSMB->SetupCount = 1;
6023 pSMB->Reserved3 = 0;
6024 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6025 byte_count = 3 /* pad */ + params + count;
6026 pSMB->ParameterCount = cpu_to_le16(params);
6027 pSMB->DataCount = cpu_to_le16(count);
6028 pSMB->TotalParameterCount = pSMB->ParameterCount;
6029 pSMB->TotalDataCount = pSMB->DataCount;
6030 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6031 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006032 inc_rfc1001_len(pSMB, byte_count);
Steve French50c2f752007-07-13 00:33:32 +00006033
Jeff Layton654cf142009-07-09 20:02:49 -04006034 cifs_fill_unix_set_info(data_offset, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006035
6036 pSMB->ByteCount = cpu_to_le16(byte_count);
6037 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6038 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006039 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00006040 cFYI(1, "SetPathInfo (perms) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006041
Steve French0d817bc2008-05-22 02:02:03 +00006042 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006043 if (rc == -EAGAIN)
6044 goto setPermsRetry;
6045 return rc;
6046}
6047
Linus Torvalds1da177e2005-04-16 15:20:36 -07006048#ifdef CONFIG_CIFS_XATTR
Jeff Layton31c05192010-02-10 16:18:26 -05006049/*
6050 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6051 * function used by listxattr and getxattr type calls. When ea_name is set,
6052 * it looks for that attribute name and stuffs that value into the EAData
6053 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6054 * buffer. In both cases, the return value is either the length of the
6055 * resulting data or a negative error code. If EAData is a NULL pointer then
6056 * the data isn't copied to it, but the length is returned.
6057 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006058ssize_t
Steve French96daf2b2011-05-27 04:34:02 +00006059CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
Jeff Layton31c05192010-02-10 16:18:26 -05006060 const unsigned char *searchName, const unsigned char *ea_name,
6061 char *EAData, size_t buf_size,
6062 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006063{
6064 /* BB assumes one setup word */
6065 TRANSACTION2_QPI_REQ *pSMB = NULL;
6066 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6067 int rc = 0;
6068 int bytes_returned;
Jeff Layton6e462b92010-02-10 16:18:26 -05006069 int list_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006070 struct fealist *ea_response_data;
Steve French50c2f752007-07-13 00:33:32 +00006071 struct fea *temp_fea;
6072 char *temp_ptr;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006073 char *end_of_smb;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006074 __u16 params, byte_count, data_offset;
Jeff Layton5980fc92011-07-28 12:48:26 -04006075 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006076
Joe Perchesb6b38f72010-04-21 03:50:45 +00006077 cFYI(1, "In Query All EAs path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006078QAllEAsRetry:
6079 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6080 (void **) &pSMBr);
6081 if (rc)
6082 return rc;
6083
6084 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Jeff Layton6e462b92010-02-10 16:18:26 -05006085 list_len =
Steve French50c2f752007-07-13 00:33:32 +00006086 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
Steve French737b7582005-04-28 22:41:06 -07006087 PATH_MAX, nls_codepage, remap);
Jeff Layton6e462b92010-02-10 16:18:26 -05006088 list_len++; /* trailing null */
6089 list_len *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006090 } else { /* BB improve the check for buffer overruns BB */
Jeff Layton6e462b92010-02-10 16:18:26 -05006091 list_len = strnlen(searchName, PATH_MAX);
6092 list_len++; /* trailing null */
6093 strncpy(pSMB->FileName, searchName, list_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006094 }
6095
Jeff Layton6e462b92010-02-10 16:18:26 -05006096 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006097 pSMB->TotalDataCount = 0;
6098 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006099 /* BB find exact max SMB PDU from sess structure BB */
Jeff Laytone5296142010-02-10 16:18:26 -05006100 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006101 pSMB->MaxSetupCount = 0;
6102 pSMB->Reserved = 0;
6103 pSMB->Flags = 0;
6104 pSMB->Timeout = 0;
6105 pSMB->Reserved2 = 0;
6106 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00006107 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006108 pSMB->DataCount = 0;
6109 pSMB->DataOffset = 0;
6110 pSMB->SetupCount = 1;
6111 pSMB->Reserved3 = 0;
6112 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6113 byte_count = params + 1 /* pad */ ;
6114 pSMB->TotalParameterCount = cpu_to_le16(params);
6115 pSMB->ParameterCount = pSMB->TotalParameterCount;
6116 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6117 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006118 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006119 pSMB->ByteCount = cpu_to_le16(byte_count);
6120
6121 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6122 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6123 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006124 cFYI(1, "Send error in QueryAllEAs = %d", rc);
Jeff Laytonf0d38682010-02-10 16:18:26 -05006125 goto QAllEAsOut;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006126 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006127
6128
6129 /* BB also check enough total bytes returned */
6130 /* BB we need to improve the validity checking
6131 of these trans2 responses */
6132
6133 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Jeff Layton820a8032011-05-04 08:05:26 -04006134 if (rc || get_bcc(&pSMBr->hdr) < 4) {
Jeff Laytonf0d38682010-02-10 16:18:26 -05006135 rc = -EIO; /* bad smb */
6136 goto QAllEAsOut;
6137 }
6138
6139 /* check that length of list is not more than bcc */
6140 /* check that each entry does not go beyond length
6141 of list */
6142 /* check that each element of each entry does not
6143 go beyond end of list */
6144 /* validate_trans2_offsets() */
6145 /* BB check if start of smb + data_offset > &bcc+ bcc */
6146
6147 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6148 ea_response_data = (struct fealist *)
6149 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6150
Jeff Layton6e462b92010-02-10 16:18:26 -05006151 list_len = le32_to_cpu(ea_response_data->list_len);
Joe Perchesb6b38f72010-04-21 03:50:45 +00006152 cFYI(1, "ea length %d", list_len);
Jeff Layton6e462b92010-02-10 16:18:26 -05006153 if (list_len <= 8) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006154 cFYI(1, "empty EA list returned from server");
Jeff Laytonf0d38682010-02-10 16:18:26 -05006155 goto QAllEAsOut;
6156 }
6157
Jeff Layton0cd126b2010-02-10 16:18:26 -05006158 /* make sure list_len doesn't go past end of SMB */
Jeff Layton690c5222011-01-20 13:36:51 -05006159 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
Jeff Layton0cd126b2010-02-10 16:18:26 -05006160 if ((char *)ea_response_data + list_len > end_of_smb) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006161 cFYI(1, "EA list appears to go beyond SMB");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006162 rc = -EIO;
6163 goto QAllEAsOut;
6164 }
6165
Jeff Laytonf0d38682010-02-10 16:18:26 -05006166 /* account for ea list len */
Jeff Layton6e462b92010-02-10 16:18:26 -05006167 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006168 temp_fea = ea_response_data->list;
6169 temp_ptr = (char *)temp_fea;
Jeff Layton6e462b92010-02-10 16:18:26 -05006170 while (list_len > 0) {
Steve French122ca002010-02-24 21:56:48 +00006171 unsigned int name_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006172 __u16 value_len;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006173
Jeff Layton6e462b92010-02-10 16:18:26 -05006174 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006175 temp_ptr += 4;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006176 /* make sure we can read name_len and value_len */
6177 if (list_len < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006178 cFYI(1, "EA entry goes beyond length of list");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006179 rc = -EIO;
6180 goto QAllEAsOut;
6181 }
6182
6183 name_len = temp_fea->name_len;
6184 value_len = le16_to_cpu(temp_fea->value_len);
6185 list_len -= name_len + 1 + value_len;
6186 if (list_len < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006187 cFYI(1, "EA entry goes beyond length of list");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006188 rc = -EIO;
6189 goto QAllEAsOut;
6190 }
6191
Jeff Layton31c05192010-02-10 16:18:26 -05006192 if (ea_name) {
Jeff Layton91d065c2011-07-26 18:23:47 -04006193 if (ea_name_len == name_len &&
Jeff Laytonac423442011-10-11 06:41:32 -04006194 memcmp(ea_name, temp_ptr, name_len) == 0) {
Jeff Layton31c05192010-02-10 16:18:26 -05006195 temp_ptr += name_len + 1;
6196 rc = value_len;
6197 if (buf_size == 0)
6198 goto QAllEAsOut;
6199 if ((size_t)value_len > buf_size) {
6200 rc = -ERANGE;
6201 goto QAllEAsOut;
6202 }
6203 memcpy(EAData, temp_ptr, value_len);
6204 goto QAllEAsOut;
6205 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006206 } else {
Jeff Layton31c05192010-02-10 16:18:26 -05006207 /* account for prefix user. and trailing null */
6208 rc += (5 + 1 + name_len);
6209 if (rc < (int) buf_size) {
6210 memcpy(EAData, "user.", 5);
6211 EAData += 5;
6212 memcpy(EAData, temp_ptr, name_len);
6213 EAData += name_len;
6214 /* null terminate name */
6215 *EAData = 0;
6216 ++EAData;
6217 } else if (buf_size == 0) {
6218 /* skip copy - calc size only */
6219 } else {
6220 /* stop before overrun buffer */
6221 rc = -ERANGE;
6222 break;
6223 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006224 }
Jeff Layton0cd126b2010-02-10 16:18:26 -05006225 temp_ptr += name_len + 1 + value_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006226 temp_fea = (struct fea *)temp_ptr;
6227 }
6228
Jeff Layton31c05192010-02-10 16:18:26 -05006229 /* didn't find the named attribute */
6230 if (ea_name)
6231 rc = -ENODATA;
6232
Jeff Laytonf0d38682010-02-10 16:18:26 -05006233QAllEAsOut:
Steve French0d817bc2008-05-22 02:02:03 +00006234 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006235 if (rc == -EAGAIN)
6236 goto QAllEAsRetry;
6237
6238 return (ssize_t)rc;
6239}
6240
Linus Torvalds1da177e2005-04-16 15:20:36 -07006241int
Steve French96daf2b2011-05-27 04:34:02 +00006242CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French50c2f752007-07-13 00:33:32 +00006243 const char *ea_name, const void *ea_value,
6244 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6245 int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006246{
6247 struct smb_com_transaction2_spi_req *pSMB = NULL;
6248 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6249 struct fealist *parm_data;
6250 int name_len;
6251 int rc = 0;
6252 int bytes_returned = 0;
6253 __u16 params, param_offset, byte_count, offset, count;
6254
Joe Perchesb6b38f72010-04-21 03:50:45 +00006255 cFYI(1, "In SetEA");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006256SetEARetry:
6257 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6258 (void **) &pSMBr);
6259 if (rc)
6260 return rc;
6261
6262 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6263 name_len =
Steve French50c2f752007-07-13 00:33:32 +00006264 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
Steve French737b7582005-04-28 22:41:06 -07006265 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006266 name_len++; /* trailing null */
6267 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00006268 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006269 name_len = strnlen(fileName, PATH_MAX);
6270 name_len++; /* trailing null */
6271 strncpy(pSMB->FileName, fileName, name_len);
6272 }
6273
6274 params = 6 + name_len;
6275
6276 /* done calculating parms using name_len of file name,
6277 now use name_len to calculate length of ea name
6278 we are going to create in the inode xattrs */
Steve French790fe572007-07-07 19:25:05 +00006279 if (ea_name == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006280 name_len = 0;
6281 else
Steve French50c2f752007-07-13 00:33:32 +00006282 name_len = strnlen(ea_name, 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006283
Steve Frenchdae5dbd2007-12-30 23:49:57 +00006284 count = sizeof(*parm_data) + ea_value_len + name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006285 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006286 /* BB find max SMB PDU from sess */
6287 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006288 pSMB->MaxSetupCount = 0;
6289 pSMB->Reserved = 0;
6290 pSMB->Flags = 0;
6291 pSMB->Timeout = 0;
6292 pSMB->Reserved2 = 0;
6293 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006294 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006295 offset = param_offset + params;
6296 pSMB->InformationLevel =
6297 cpu_to_le16(SMB_SET_FILE_EA);
6298
6299 parm_data =
6300 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6301 offset);
6302 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6303 pSMB->DataOffset = cpu_to_le16(offset);
6304 pSMB->SetupCount = 1;
6305 pSMB->Reserved3 = 0;
6306 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6307 byte_count = 3 /* pad */ + params + count;
6308 pSMB->DataCount = cpu_to_le16(count);
6309 parm_data->list_len = cpu_to_le32(count);
6310 parm_data->list[0].EA_flags = 0;
6311 /* we checked above that name len is less than 255 */
Alexey Dobriyan53b35312006-03-24 03:16:13 -08006312 parm_data->list[0].name_len = (__u8)name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006313 /* EA names are always ASCII */
Steve French790fe572007-07-07 19:25:05 +00006314 if (ea_name)
Steve French50c2f752007-07-13 00:33:32 +00006315 strncpy(parm_data->list[0].name, ea_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006316 parm_data->list[0].name[name_len] = 0;
6317 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6318 /* caller ensures that ea_value_len is less than 64K but
6319 we need to ensure that it fits within the smb */
6320
Steve French50c2f752007-07-13 00:33:32 +00006321 /*BB add length check to see if it would fit in
6322 negotiated SMB buffer size BB */
Steve French790fe572007-07-07 19:25:05 +00006323 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6324 if (ea_value_len)
Steve French50c2f752007-07-13 00:33:32 +00006325 memcpy(parm_data->list[0].name+name_len+1,
6326 ea_value, ea_value_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006327
6328 pSMB->TotalDataCount = pSMB->DataCount;
6329 pSMB->ParameterCount = cpu_to_le16(params);
6330 pSMB->TotalParameterCount = pSMB->ParameterCount;
6331 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006332 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006333 pSMB->ByteCount = cpu_to_le16(byte_count);
6334 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6335 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006336 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00006337 cFYI(1, "SetPathInfo (EA) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006338
6339 cifs_buf_release(pSMB);
6340
6341 if (rc == -EAGAIN)
6342 goto SetEARetry;
6343
6344 return rc;
6345}
Linus Torvalds1da177e2005-04-16 15:20:36 -07006346#endif
Steve French0eff0e22011-02-24 05:39:23 +00006347
6348#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6349/*
6350 * Years ago the kernel added a "dnotify" function for Samba server,
6351 * to allow network clients (such as Windows) to display updated
6352 * lists of files in directory listings automatically when
6353 * files are added by one user when another user has the
6354 * same directory open on their desktop. The Linux cifs kernel
6355 * client hooked into the kernel side of this interface for
6356 * the same reason, but ironically when the VFS moved from
6357 * "dnotify" to "inotify" it became harder to plug in Linux
6358 * network file system clients (the most obvious use case
6359 * for notify interfaces is when multiple users can update
6360 * the contents of the same directory - exactly what network
6361 * file systems can do) although the server (Samba) could
6362 * still use it. For the short term we leave the worker
6363 * function ifdeffed out (below) until inotify is fixed
6364 * in the VFS to make it easier to plug in network file
6365 * system clients. If inotify turns out to be permanently
6366 * incompatible for network fs clients, we could instead simply
6367 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6368 */
Steve French96daf2b2011-05-27 04:34:02 +00006369int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
Steve French0eff0e22011-02-24 05:39:23 +00006370 const int notify_subdirs, const __u16 netfid,
6371 __u32 filter, struct file *pfile, int multishot,
6372 const struct nls_table *nls_codepage)
6373{
6374 int rc = 0;
6375 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6376 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6377 struct dir_notify_req *dnotify_req;
6378 int bytes_returned;
6379
6380 cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
6381 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6382 (void **) &pSMBr);
6383 if (rc)
6384 return rc;
6385
6386 pSMB->TotalParameterCount = 0 ;
6387 pSMB->TotalDataCount = 0;
6388 pSMB->MaxParameterCount = cpu_to_le32(2);
Jeff Laytonc974bef2011-10-11 06:41:32 -04006389 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Steve French0eff0e22011-02-24 05:39:23 +00006390 pSMB->MaxSetupCount = 4;
6391 pSMB->Reserved = 0;
6392 pSMB->ParameterOffset = 0;
6393 pSMB->DataCount = 0;
6394 pSMB->DataOffset = 0;
6395 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6396 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6397 pSMB->ParameterCount = pSMB->TotalParameterCount;
6398 if (notify_subdirs)
6399 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6400 pSMB->Reserved2 = 0;
6401 pSMB->CompletionFilter = cpu_to_le32(filter);
6402 pSMB->Fid = netfid; /* file handle always le */
6403 pSMB->ByteCount = 0;
6404
6405 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6406 (struct smb_hdr *)pSMBr, &bytes_returned,
6407 CIFS_ASYNC_OP);
6408 if (rc) {
6409 cFYI(1, "Error in Notify = %d", rc);
6410 } else {
6411 /* Add file to outstanding requests */
6412 /* BB change to kmem cache alloc */
6413 dnotify_req = kmalloc(
6414 sizeof(struct dir_notify_req),
6415 GFP_KERNEL);
6416 if (dnotify_req) {
6417 dnotify_req->Pid = pSMB->hdr.Pid;
6418 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6419 dnotify_req->Mid = pSMB->hdr.Mid;
6420 dnotify_req->Tid = pSMB->hdr.Tid;
6421 dnotify_req->Uid = pSMB->hdr.Uid;
6422 dnotify_req->netfid = netfid;
6423 dnotify_req->pfile = pfile;
6424 dnotify_req->filter = filter;
6425 dnotify_req->multishot = multishot;
6426 spin_lock(&GlobalMid_Lock);
6427 list_add_tail(&dnotify_req->lhead,
6428 &GlobalDnotifyReqList);
6429 spin_unlock(&GlobalMid_Lock);
6430 } else
6431 rc = -ENOMEM;
6432 }
6433 cifs_buf_release(pSMB);
6434 return rc;
6435}
6436#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */