blob: 21ff4bff6c897737a2ecae2a208c5fd743ae82e9 [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);
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300461 server->maxReq = min_t(unsigned int,
462 le16_to_cpu(rsp->MaxMpxCount),
463 cifs_max_pending);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400464 cifs_set_credits(server, server->maxReq);
Jeff Laytonc974bef2011-10-11 06:41:32 -0400465 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
Steve Frencheca6acf2009-02-20 05:43:09 +0000466 server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
Steve French254e55e2006-06-04 05:53:15 +0000467 /* even though we do not use raw we might as well set this
468 accurately, in case we ever find a need for it */
Steve French790fe572007-07-07 19:25:05 +0000469 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
Steve Frencheca6acf2009-02-20 05:43:09 +0000470 server->max_rw = 0xFF00;
Steve French254e55e2006-06-04 05:53:15 +0000471 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
472 } else {
Steve Frencheca6acf2009-02-20 05:43:09 +0000473 server->max_rw = 0;/* do not need to use raw anyway */
Steve French254e55e2006-06-04 05:53:15 +0000474 server->capabilities = CAP_MPX_MODE;
475 }
Steve Frenchb815f1e2006-10-02 05:53:29 +0000476 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
Steve French1a70d652006-10-02 05:59:18 +0000477 if (tmp == -1) {
Steve French25ee4a92006-09-30 00:54:23 +0000478 /* OS/2 often does not set timezone therefore
479 * we must use server time to calc time zone.
Steve Frenchb815f1e2006-10-02 05:53:29 +0000480 * Could deviate slightly from the right zone.
481 * Smallest defined timezone difference is 15 minutes
482 * (i.e. Nepal). Rounding up/down is done to match
483 * this requirement.
Steve French25ee4a92006-09-30 00:54:23 +0000484 */
Steve Frenchb815f1e2006-10-02 05:53:29 +0000485 int val, seconds, remain, result;
Steve French25ee4a92006-09-30 00:54:23 +0000486 struct timespec ts, utc;
487 utc = CURRENT_TIME;
Jeff Laytonc4a2c082009-05-27 09:37:33 -0400488 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
489 rsp->SrvTime.Time, 0);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000490 cFYI(1, "SrvTime %d sec since 1970 (utc: %d) diff: %d",
Steve French50c2f752007-07-13 00:33:32 +0000491 (int)ts.tv_sec, (int)utc.tv_sec,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000492 (int)(utc.tv_sec - ts.tv_sec));
Steve Frenchb815f1e2006-10-02 05:53:29 +0000493 val = (int)(utc.tv_sec - ts.tv_sec);
Andre Haupt8594c152007-08-30 20:18:41 +0000494 seconds = abs(val);
Steve French947a5062006-10-02 05:55:25 +0000495 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
Steve Frenchb815f1e2006-10-02 05:53:29 +0000496 remain = seconds % MIN_TZ_ADJ;
Steve French790fe572007-07-07 19:25:05 +0000497 if (remain >= (MIN_TZ_ADJ / 2))
Steve Frenchb815f1e2006-10-02 05:53:29 +0000498 result += MIN_TZ_ADJ;
Steve French790fe572007-07-07 19:25:05 +0000499 if (val < 0)
Steve Frenchad7a2922008-02-07 23:25:02 +0000500 result = -result;
Steve Frenchb815f1e2006-10-02 05:53:29 +0000501 server->timeAdj = result;
Steve French25ee4a92006-09-30 00:54:23 +0000502 } else {
Steve Frenchb815f1e2006-10-02 05:53:29 +0000503 server->timeAdj = (int)tmp;
504 server->timeAdj *= 60; /* also in seconds */
Steve French25ee4a92006-09-30 00:54:23 +0000505 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000506 cFYI(1, "server->timeAdj: %d seconds", server->timeAdj);
Steve French25ee4a92006-09-30 00:54:23 +0000507
Steve French39798772006-05-31 22:40:51 +0000508
Steve French254e55e2006-06-04 05:53:15 +0000509 /* BB get server time for time conversions and add
Steve French50c2f752007-07-13 00:33:32 +0000510 code to use it and timezone since this is not UTC */
Steve French39798772006-05-31 22:40:51 +0000511
Steve French50c2f752007-07-13 00:33:32 +0000512 if (rsp->EncryptionKeyLength ==
Steve French25ee4a92006-09-30 00:54:23 +0000513 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500514 memcpy(ses->server->cryptkey, rsp->EncryptionKey,
Steve French254e55e2006-06-04 05:53:15 +0000515 CIFS_CRYPTO_KEY_SIZE);
Steve French96daf2b2011-05-27 04:34:02 +0000516 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
Steve French254e55e2006-06-04 05:53:15 +0000517 rc = -EIO; /* need cryptkey unless plain text */
518 goto neg_err_exit;
519 }
Steve French39798772006-05-31 22:40:51 +0000520
Steve Frenchf19159d2010-04-21 04:12:10 +0000521 cFYI(1, "LANMAN negotiated");
Steve French254e55e2006-06-04 05:53:15 +0000522 /* we will not end up setting signing flags - as no signing
523 was in LANMAN and server did not return the flags on */
524 goto signing_check;
Steve French7c7b25b2006-06-01 19:20:10 +0000525#else /* weak security disabled */
Steve French790fe572007-07-07 19:25:05 +0000526 } else if (pSMBr->hdr.WordCount == 13) {
Steve Frenchf19159d2010-04-21 04:12:10 +0000527 cERROR(1, "mount failed, cifs module not built "
528 "with CIFS_WEAK_PW_HASH support");
Dan Carpenter8212cf72010-03-15 11:22:26 +0300529 rc = -EOPNOTSUPP;
Steve French7c7b25b2006-06-01 19:20:10 +0000530#endif /* WEAK_PW_HASH */
Steve French254e55e2006-06-04 05:53:15 +0000531 goto neg_err_exit;
Steve French790fe572007-07-07 19:25:05 +0000532 } else if (pSMBr->hdr.WordCount != 17) {
Steve French254e55e2006-06-04 05:53:15 +0000533 /* unknown wct */
534 rc = -EOPNOTSUPP;
535 goto neg_err_exit;
536 }
537 /* else wct == 17 NTLM */
Steve French96daf2b2011-05-27 04:34:02 +0000538 server->sec_mode = pSMBr->SecurityMode;
539 if ((server->sec_mode & SECMODE_USER) == 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000540 cFYI(1, "share mode security");
Steve French39798772006-05-31 22:40:51 +0000541
Steve French96daf2b2011-05-27 04:34:02 +0000542 if ((server->sec_mode & SECMODE_PW_ENCRYPT) == 0)
Steve Frenchbdc4bf6e2006-06-02 22:57:13 +0000543#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French750d1152006-06-27 06:28:30 +0000544 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
Steve Frenchbdc4bf6e2006-06-02 22:57:13 +0000545#endif /* CIFS_WEAK_PW_HASH */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000546 cERROR(1, "Server requests plain text password"
547 " but client support disabled");
Steve French9312f672006-06-04 22:21:07 +0000548
Steve French790fe572007-07-07 19:25:05 +0000549 if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
Steve French254e55e2006-06-04 05:53:15 +0000550 server->secType = NTLMv2;
Steve French790fe572007-07-07 19:25:05 +0000551 else if (secFlags & CIFSSEC_MAY_NTLM)
Steve French254e55e2006-06-04 05:53:15 +0000552 server->secType = NTLM;
Steve French790fe572007-07-07 19:25:05 +0000553 else if (secFlags & CIFSSEC_MAY_NTLMV2)
Steve Frenchf40c5622006-06-28 00:13:38 +0000554 server->secType = NTLMv2;
Steve Frencha0136892007-10-04 20:05:09 +0000555 else if (secFlags & CIFSSEC_MAY_KRB5)
556 server->secType = Kerberos;
Steve Frenchac683922009-05-06 04:16:04 +0000557 else if (secFlags & CIFSSEC_MAY_NTLMSSP)
Steve Frenchf46c7232009-06-25 03:04:20 +0000558 server->secType = RawNTLMSSP;
Steve Frencha0136892007-10-04 20:05:09 +0000559 else if (secFlags & CIFSSEC_MAY_LANMAN)
560 server->secType = LANMAN;
Steve Frencha0136892007-10-04 20:05:09 +0000561 else {
562 rc = -EOPNOTSUPP;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000563 cERROR(1, "Invalid security type");
Steve Frencha0136892007-10-04 20:05:09 +0000564 goto neg_err_exit;
565 }
566 /* else ... any others ...? */
Steve French7c7b25b2006-06-01 19:20:10 +0000567
Steve French254e55e2006-06-04 05:53:15 +0000568 /* one byte, so no need to convert this or EncryptionKeyLen from
569 little endian */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300570 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
571 cifs_max_pending);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400572 cifs_set_credits(server, server->maxReq);
Steve French254e55e2006-06-04 05:53:15 +0000573 /* probably no need to store and check maxvcs */
Jeff Laytonc974bef2011-10-11 06:41:32 -0400574 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
Steve Frencheca6acf2009-02-20 05:43:09 +0000575 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000576 cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
Steve French254e55e2006-06-04 05:53:15 +0000577 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
Steve Frenchb815f1e2006-10-02 05:53:29 +0000578 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
579 server->timeAdj *= 60;
Steve French254e55e2006-06-04 05:53:15 +0000580 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500581 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
Steve French254e55e2006-06-04 05:53:15 +0000582 CIFS_CRYPTO_KEY_SIZE);
Steve French07cc6cf2011-05-27 04:12:29 +0000583 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
584 server->capabilities & CAP_EXTENDED_SECURITY) &&
585 (pSMBr->EncryptionKeyLength == 0)) {
Steve French254e55e2006-06-04 05:53:15 +0000586 /* decode security blob */
Jeff Layton820a8032011-05-04 08:05:26 -0400587 count = get_bcc(&pSMBr->hdr);
Jeff Laytone187e442007-10-16 17:10:44 +0000588 if (count < 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 rc = -EIO;
Jeff Laytone187e442007-10-16 17:10:44 +0000590 goto neg_err_exit;
591 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530592 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500593 if (server->srv_count > 1) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530594 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone187e442007-10-16 17:10:44 +0000595 if (memcmp(server->server_GUID,
596 pSMBr->u.extended_response.
597 GUID, 16) != 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000598 cFYI(1, "server UID changed");
Steve French254e55e2006-06-04 05:53:15 +0000599 memcpy(server->server_GUID,
Jeff Laytone187e442007-10-16 17:10:44 +0000600 pSMBr->u.extended_response.GUID,
601 16);
602 }
Jeff Laytone7ddee92008-11-14 13:44:38 -0500603 } else {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530604 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone187e442007-10-16 17:10:44 +0000605 memcpy(server->server_GUID,
606 pSMBr->u.extended_response.GUID, 16);
Jeff Laytone7ddee92008-11-14 13:44:38 -0500607 }
Jeff Laytone187e442007-10-16 17:10:44 +0000608
609 if (count == 16) {
610 server->secType = RawNTLMSSP;
Steve French254e55e2006-06-04 05:53:15 +0000611 } else {
612 rc = decode_negTokenInit(pSMBr->u.extended_response.
Jeff Layton26efa0b2010-04-24 07:57:49 -0400613 SecurityBlob, count - 16,
614 server);
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +0000615 if (rc == 1)
Jeff Laytone5459372007-11-03 05:11:06 +0000616 rc = 0;
Shirish Pargaonkaref571ca2008-07-24 15:56:05 +0000617 else
Steve French254e55e2006-06-04 05:53:15 +0000618 rc = -EINVAL;
Shirish Pargaonkar2b149f12010-09-18 22:02:18 -0500619 if (server->secType == Kerberos) {
620 if (!server->sec_kerberos &&
621 !server->sec_mskerberos)
622 rc = -EOPNOTSUPP;
623 } else if (server->secType == RawNTLMSSP) {
624 if (!server->sec_ntlmssp)
625 rc = -EOPNOTSUPP;
626 } else
627 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 }
Steve French96daf2b2011-05-27 04:34:02 +0000629 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
Steve French07cc6cf2011-05-27 04:12:29 +0000630 rc = -EIO; /* no crypt key only if plain text pwd */
631 goto neg_err_exit;
Steve French254e55e2006-06-04 05:53:15 +0000632 } else
633 server->capabilities &= ~CAP_EXTENDED_SECURITY;
634
Steve French6344a422006-06-12 04:18:35 +0000635#ifdef CONFIG_CIFS_WEAK_PW_HASH
Steve French254e55e2006-06-04 05:53:15 +0000636signing_check:
Steve French6344a422006-06-12 04:18:35 +0000637#endif
Steve French762e5ab2007-06-28 18:41:42 +0000638 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
639 /* MUST_SIGN already includes the MAY_SIGN FLAG
640 so if this is zero it means that signing is disabled */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000641 cFYI(1, "Signing disabled");
Steve French96daf2b2011-05-27 04:34:02 +0000642 if (server->sec_mode & SECMODE_SIGN_REQUIRED) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000643 cERROR(1, "Server requires "
Jeff Layton7111d212007-10-16 16:50:25 +0000644 "packet signing to be enabled in "
Joe Perchesb6b38f72010-04-21 03:50:45 +0000645 "/proc/fs/cifs/SecurityFlags.");
Steve Frenchabb63d62007-10-18 02:58:40 +0000646 rc = -EOPNOTSUPP;
647 }
Steve French96daf2b2011-05-27 04:34:02 +0000648 server->sec_mode &=
Steve French254e55e2006-06-04 05:53:15 +0000649 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
Steve French762e5ab2007-06-28 18:41:42 +0000650 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
651 /* signing required */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000652 cFYI(1, "Must sign - secFlags 0x%x", secFlags);
Steve French96daf2b2011-05-27 04:34:02 +0000653 if ((server->sec_mode &
Steve French762e5ab2007-06-28 18:41:42 +0000654 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000655 cERROR(1, "signing required but server lacks support");
Jeff38c10a12007-07-06 21:10:07 +0000656 rc = -EOPNOTSUPP;
Steve French762e5ab2007-06-28 18:41:42 +0000657 } else
Steve French96daf2b2011-05-27 04:34:02 +0000658 server->sec_mode |= SECMODE_SIGN_REQUIRED;
Steve French762e5ab2007-06-28 18:41:42 +0000659 } else {
660 /* signing optional ie CIFSSEC_MAY_SIGN */
Steve French96daf2b2011-05-27 04:34:02 +0000661 if ((server->sec_mode & SECMODE_SIGN_REQUIRED) == 0)
662 server->sec_mode &=
Steve French254e55e2006-06-04 05:53:15 +0000663 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 }
Steve French50c2f752007-07-13 00:33:32 +0000665
666neg_err_exit:
Steve French4a6d87f2005-08-13 08:15:54 -0700667 cifs_buf_release(pSMB);
Steve French254e55e2006-06-04 05:53:15 +0000668
Joe Perchesb6b38f72010-04-21 03:50:45 +0000669 cFYI(1, "negprot rc %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return rc;
671}
672
673int
Steve French96daf2b2011-05-27 04:34:02 +0000674CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675{
676 struct smb_hdr *smb_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Joe Perchesb6b38f72010-04-21 03:50:45 +0000679 cFYI(1, "In tree disconnect");
Jeff Laytonf1987b42008-11-15 11:12:47 -0500680
681 /* BB: do we need to check this? These should never be NULL. */
682 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
683 return -EIO;
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 /*
Jeff Laytonf1987b42008-11-15 11:12:47 -0500686 * No need to return error on this operation if tid invalidated and
687 * closed on server already e.g. due to tcp session crashing. Also,
688 * the tcon is no longer on the list, so no need to take lock before
689 * checking this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 */
Steve French268875b2009-06-25 00:29:21 +0000691 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
Steve French50c2f752007-07-13 00:33:32 +0000692 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Steve French50c2f752007-07-13 00:33:32 +0000694 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
Steve French09d1db52005-04-28 22:41:08 -0700695 (void **)&smb_buffer);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500696 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 return rc;
Steve French133672e2007-11-13 22:41:37 +0000698
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400699 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000701 cFYI(1, "Tree disconnect failed %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Steve French50c2f752007-07-13 00:33:32 +0000703 /* No need to return error on this operation if tid invalidated and
Jeff Laytonf1987b42008-11-15 11:12:47 -0500704 closed on server already e.g. due to tcp session crashing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 if (rc == -EAGAIN)
706 rc = 0;
707
708 return rc;
709}
710
Jeff Layton766fdbb2011-01-11 07:24:21 -0500711/*
712 * This is a no-op for now. We're not really interested in the reply, but
713 * rather in the fact that the server sent one and that server->lstrp
714 * gets updated.
715 *
716 * FIXME: maybe we should consider checking that the reply matches request?
717 */
718static void
719cifs_echo_callback(struct mid_q_entry *mid)
720{
721 struct TCP_Server_Info *server = mid->callback_data;
722
723 DeleteMidQEntry(mid);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400724 cifs_add_credits(server, 1);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500725}
726
727int
728CIFSSMBEcho(struct TCP_Server_Info *server)
729{
730 ECHO_REQ *smb;
731 int rc = 0;
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400732 struct kvec iov;
Jeff Layton766fdbb2011-01-11 07:24:21 -0500733
734 cFYI(1, "In echo request");
735
736 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
737 if (rc)
738 return rc;
739
740 /* set up echo request */
Steve French5443d132011-03-13 05:08:25 +0000741 smb->hdr.Tid = 0xffff;
Jeff Layton99d86c82011-01-20 21:19:25 -0500742 smb->hdr.WordCount = 1;
743 put_unaligned_le16(1, &smb->EchoCount);
Jeff Layton820a8032011-05-04 08:05:26 -0400744 put_bcc(1, &smb->hdr);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500745 smb->Data[0] = 'a';
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000746 inc_rfc1001_len(smb, 3);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400747 iov.iov_base = smb;
748 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
Jeff Layton766fdbb2011-01-11 07:24:21 -0500749
Jeff Layton44d22d82011-10-19 15:29:49 -0400750 rc = cifs_call_async(server, &iov, 1, NULL, cifs_echo_callback,
751 server, true);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500752 if (rc)
753 cFYI(1, "Echo request failed: %d", rc);
754
755 cifs_small_buf_release(smb);
756
757 return rc;
758}
759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760int
Steve French96daf2b2011-05-27 04:34:02 +0000761CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 LOGOFF_ANDX_REQ *pSMB;
764 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Joe Perchesb6b38f72010-04-21 03:50:45 +0000766 cFYI(1, "In SMBLogoff for session disconnect");
Jeff Layton14fbf502008-11-14 13:53:46 -0500767
768 /*
769 * BB: do we need to check validity of ses and server? They should
770 * always be valid since we have an active reference. If not, that
771 * should probably be a BUG()
772 */
773 if (!ses || !ses->server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 return -EIO;
775
Steve Frenchd7b619c2010-02-25 05:36:46 +0000776 mutex_lock(&ses->session_mutex);
Steve French3b795212008-11-13 19:45:32 +0000777 if (ses->need_reconnect)
778 goto session_already_dead; /* no need to send SMBlogoff if uid
779 already closed due to reconnect */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
781 if (rc) {
Steve Frenchd7b619c2010-02-25 05:36:46 +0000782 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 return rc;
784 }
785
Steve French3b795212008-11-13 19:45:32 +0000786 pSMB->hdr.Mid = GetNextMid(ses->server);
Steve French1982c342005-08-17 12:38:22 -0700787
Steve French96daf2b2011-05-27 04:34:02 +0000788 if (ses->server->sec_mode &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
790 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
792 pSMB->hdr.Uid = ses->Suid;
793
794 pSMB->AndXCommand = 0xFF;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400795 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
Steve French3b795212008-11-13 19:45:32 +0000796session_already_dead:
Steve Frenchd7b619c2010-02-25 05:36:46 +0000797 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799 /* if session dead then we do not need to do ulogoff,
Steve French50c2f752007-07-13 00:33:32 +0000800 since server closed smb session, no sense reporting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 error */
802 if (rc == -EAGAIN)
803 rc = 0;
804 return rc;
805}
806
807int
Steve French96daf2b2011-05-27 04:34:02 +0000808CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French2d785a52007-07-15 01:48:57 +0000809 __u16 type, const struct nls_table *nls_codepage, int remap)
810{
811 TRANSACTION2_SPI_REQ *pSMB = NULL;
812 TRANSACTION2_SPI_RSP *pSMBr = NULL;
813 struct unlink_psx_rq *pRqD;
814 int name_len;
815 int rc = 0;
816 int bytes_returned = 0;
817 __u16 params, param_offset, offset, byte_count;
818
Joe Perchesb6b38f72010-04-21 03:50:45 +0000819 cFYI(1, "In POSIX delete");
Steve French2d785a52007-07-15 01:48:57 +0000820PsxDelete:
821 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
822 (void **) &pSMBr);
823 if (rc)
824 return rc;
825
826 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
827 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -0600828 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
829 PATH_MAX, nls_codepage, remap);
Steve French2d785a52007-07-15 01:48:57 +0000830 name_len++; /* trailing null */
831 name_len *= 2;
832 } else { /* BB add path length overrun check */
833 name_len = strnlen(fileName, PATH_MAX);
834 name_len++; /* trailing null */
835 strncpy(pSMB->FileName, fileName, name_len);
836 }
837
838 params = 6 + name_len;
839 pSMB->MaxParameterCount = cpu_to_le16(2);
840 pSMB->MaxDataCount = 0; /* BB double check this with jra */
841 pSMB->MaxSetupCount = 0;
842 pSMB->Reserved = 0;
843 pSMB->Flags = 0;
844 pSMB->Timeout = 0;
845 pSMB->Reserved2 = 0;
846 param_offset = offsetof(struct smb_com_transaction2_spi_req,
847 InformationLevel) - 4;
848 offset = param_offset + params;
849
850 /* Setup pointer to Request Data (inode type) */
851 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
852 pRqD->type = cpu_to_le16(type);
853 pSMB->ParameterOffset = cpu_to_le16(param_offset);
854 pSMB->DataOffset = cpu_to_le16(offset);
855 pSMB->SetupCount = 1;
856 pSMB->Reserved3 = 0;
857 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
858 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
859
860 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
861 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
862 pSMB->ParameterCount = cpu_to_le16(params);
863 pSMB->TotalParameterCount = pSMB->ParameterCount;
864 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
865 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000866 inc_rfc1001_len(pSMB, byte_count);
Steve French2d785a52007-07-15 01:48:57 +0000867 pSMB->ByteCount = cpu_to_le16(byte_count);
868 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
869 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +0000870 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000871 cFYI(1, "Posix delete returned %d", rc);
Steve French2d785a52007-07-15 01:48:57 +0000872 cifs_buf_release(pSMB);
873
874 cifs_stats_inc(&tcon->num_deletes);
875
876 if (rc == -EAGAIN)
877 goto PsxDelete;
878
879 return rc;
880}
881
882int
Steve French96daf2b2011-05-27 04:34:02 +0000883CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French737b7582005-04-28 22:41:06 -0700884 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885{
886 DELETE_FILE_REQ *pSMB = NULL;
887 DELETE_FILE_RSP *pSMBr = NULL;
888 int rc = 0;
889 int bytes_returned;
890 int name_len;
891
892DelFileRetry:
893 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
894 (void **) &pSMBr);
895 if (rc)
896 return rc;
897
898 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
899 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -0600900 cifsConvertToUTF16((__le16 *) pSMB->fileName, fileName,
901 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 name_len++; /* trailing null */
903 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700904 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 name_len = strnlen(fileName, PATH_MAX);
906 name_len++; /* trailing null */
907 strncpy(pSMB->fileName, fileName, name_len);
908 }
909 pSMB->SearchAttributes =
910 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
911 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000912 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 pSMB->ByteCount = cpu_to_le16(name_len + 1);
914 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
915 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -0700916 cifs_stats_inc(&tcon->num_deletes);
Steve Frenchad7a2922008-02-07 23:25:02 +0000917 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000918 cFYI(1, "Error in RMFile = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 cifs_buf_release(pSMB);
921 if (rc == -EAGAIN)
922 goto DelFileRetry;
923
924 return rc;
925}
926
927int
Steve French96daf2b2011-05-27 04:34:02 +0000928CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
Steve French737b7582005-04-28 22:41:06 -0700929 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930{
931 DELETE_DIRECTORY_REQ *pSMB = NULL;
932 DELETE_DIRECTORY_RSP *pSMBr = NULL;
933 int rc = 0;
934 int bytes_returned;
935 int name_len;
936
Joe Perchesb6b38f72010-04-21 03:50:45 +0000937 cFYI(1, "In CIFSSMBRmDir");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938RmDirRetry:
939 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
940 (void **) &pSMBr);
941 if (rc)
942 return rc;
943
944 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -0600945 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, dirName,
946 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 name_len++; /* trailing null */
948 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700949 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 name_len = strnlen(dirName, PATH_MAX);
951 name_len++; /* trailing null */
952 strncpy(pSMB->DirName, dirName, name_len);
953 }
954
955 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000956 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 pSMB->ByteCount = cpu_to_le16(name_len + 1);
958 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
959 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -0700960 cifs_stats_inc(&tcon->num_rmdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +0000961 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000962 cFYI(1, "Error in RMDir = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 cifs_buf_release(pSMB);
965 if (rc == -EAGAIN)
966 goto RmDirRetry;
967 return rc;
968}
969
970int
Steve French96daf2b2011-05-27 04:34:02 +0000971CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
Steve French737b7582005-04-28 22:41:06 -0700972 const char *name, const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973{
974 int rc = 0;
975 CREATE_DIRECTORY_REQ *pSMB = NULL;
976 CREATE_DIRECTORY_RSP *pSMBr = NULL;
977 int bytes_returned;
978 int name_len;
979
Joe Perchesb6b38f72010-04-21 03:50:45 +0000980 cFYI(1, "In CIFSSMBMkDir");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981MkDirRetry:
982 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
983 (void **) &pSMBr);
984 if (rc)
985 return rc;
986
987 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -0600988 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
989 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 name_len++; /* trailing null */
991 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700992 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 name_len = strnlen(name, PATH_MAX);
994 name_len++; /* trailing null */
995 strncpy(pSMB->DirName, name, name_len);
996 }
997
998 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000999 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 pSMB->ByteCount = cpu_to_le16(name_len + 1);
1001 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1002 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07001003 cifs_stats_inc(&tcon->num_mkdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +00001004 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001005 cFYI(1, "Error in Mkdir = %d", rc);
Steve Frencha5a2b482005-08-20 21:42:53 -07001006
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 cifs_buf_release(pSMB);
1008 if (rc == -EAGAIN)
1009 goto MkDirRetry;
1010 return rc;
1011}
1012
Steve French2dd29d32007-04-23 22:07:35 +00001013int
Steve French96daf2b2011-05-27 04:34:02 +00001014CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
Steve Frenchad7a2922008-02-07 23:25:02 +00001015 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
Steve French50c2f752007-07-13 00:33:32 +00001016 __u32 *pOplock, const char *name,
Steve French2dd29d32007-04-23 22:07:35 +00001017 const struct nls_table *nls_codepage, int remap)
1018{
1019 TRANSACTION2_SPI_REQ *pSMB = NULL;
1020 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1021 int name_len;
1022 int rc = 0;
1023 int bytes_returned = 0;
Steve French2dd29d32007-04-23 22:07:35 +00001024 __u16 params, param_offset, offset, byte_count, count;
Steve Frenchad7a2922008-02-07 23:25:02 +00001025 OPEN_PSX_REQ *pdata;
1026 OPEN_PSX_RSP *psx_rsp;
Steve French2dd29d32007-04-23 22:07:35 +00001027
Joe Perchesb6b38f72010-04-21 03:50:45 +00001028 cFYI(1, "In POSIX Create");
Steve French2dd29d32007-04-23 22:07:35 +00001029PsxCreat:
1030 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1031 (void **) &pSMBr);
1032 if (rc)
1033 return rc;
1034
1035 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1036 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06001037 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1038 PATH_MAX, nls_codepage, remap);
Steve French2dd29d32007-04-23 22:07:35 +00001039 name_len++; /* trailing null */
1040 name_len *= 2;
1041 } else { /* BB improve the check for buffer overruns BB */
1042 name_len = strnlen(name, PATH_MAX);
1043 name_len++; /* trailing null */
1044 strncpy(pSMB->FileName, name, name_len);
1045 }
1046
1047 params = 6 + name_len;
1048 count = sizeof(OPEN_PSX_REQ);
1049 pSMB->MaxParameterCount = cpu_to_le16(2);
1050 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1051 pSMB->MaxSetupCount = 0;
1052 pSMB->Reserved = 0;
1053 pSMB->Flags = 0;
1054 pSMB->Timeout = 0;
1055 pSMB->Reserved2 = 0;
1056 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00001057 InformationLevel) - 4;
Steve French2dd29d32007-04-23 22:07:35 +00001058 offset = param_offset + params;
Steve French2dd29d32007-04-23 22:07:35 +00001059 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001060 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
Steve French2dd29d32007-04-23 22:07:35 +00001061 pdata->Permissions = cpu_to_le64(mode);
Steve French50c2f752007-07-13 00:33:32 +00001062 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
Steve French2dd29d32007-04-23 22:07:35 +00001063 pdata->OpenFlags = cpu_to_le32(*pOplock);
1064 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1065 pSMB->DataOffset = cpu_to_le16(offset);
1066 pSMB->SetupCount = 1;
1067 pSMB->Reserved3 = 0;
1068 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1069 byte_count = 3 /* pad */ + params + count;
1070
1071 pSMB->DataCount = cpu_to_le16(count);
1072 pSMB->ParameterCount = cpu_to_le16(params);
1073 pSMB->TotalDataCount = pSMB->DataCount;
1074 pSMB->TotalParameterCount = pSMB->ParameterCount;
1075 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1076 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001077 inc_rfc1001_len(pSMB, byte_count);
Steve French2dd29d32007-04-23 22:07:35 +00001078 pSMB->ByteCount = cpu_to_le16(byte_count);
1079 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1080 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1081 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001082 cFYI(1, "Posix create returned %d", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001083 goto psx_create_err;
1084 }
1085
Joe Perchesb6b38f72010-04-21 03:50:45 +00001086 cFYI(1, "copying inode info");
Steve French2dd29d32007-04-23 22:07:35 +00001087 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1088
Jeff Layton820a8032011-05-04 08:05:26 -04001089 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
Steve French2dd29d32007-04-23 22:07:35 +00001090 rc = -EIO; /* bad smb */
1091 goto psx_create_err;
1092 }
1093
1094 /* copy return information to pRetData */
Steve French50c2f752007-07-13 00:33:32 +00001095 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
Steve French2dd29d32007-04-23 22:07:35 +00001096 + le16_to_cpu(pSMBr->t2.DataOffset));
Steve French50c2f752007-07-13 00:33:32 +00001097
Steve French2dd29d32007-04-23 22:07:35 +00001098 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
Steve French790fe572007-07-07 19:25:05 +00001099 if (netfid)
Steve French2dd29d32007-04-23 22:07:35 +00001100 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1101 /* Let caller know file was created so we can set the mode. */
1102 /* Do we care about the CreateAction in any other cases? */
Steve French790fe572007-07-07 19:25:05 +00001103 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
Steve French2dd29d32007-04-23 22:07:35 +00001104 *pOplock |= CIFS_CREATE_ACTION;
1105 /* check to make sure response data is there */
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001106 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1107 pRetData->Type = cpu_to_le32(-1); /* unknown */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001108 cFYI(DBG2, "unknown type");
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001109 } else {
Jeff Layton820a8032011-05-04 08:05:26 -04001110 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
Steve French2dd29d32007-04-23 22:07:35 +00001111 + sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001112 cERROR(1, "Open response data too small");
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001113 pRetData->Type = cpu_to_le32(-1);
Steve French2dd29d32007-04-23 22:07:35 +00001114 goto psx_create_err;
1115 }
Steve French50c2f752007-07-13 00:33:32 +00001116 memcpy((char *) pRetData,
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001117 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
Steve French26f57362007-08-30 22:09:15 +00001118 sizeof(FILE_UNIX_BASIC_INFO));
Steve French2dd29d32007-04-23 22:07:35 +00001119 }
Steve French2dd29d32007-04-23 22:07:35 +00001120
1121psx_create_err:
1122 cifs_buf_release(pSMB);
1123
Steve French65bc98b2009-07-10 15:27:25 +00001124 if (posix_flags & SMB_O_DIRECTORY)
1125 cifs_stats_inc(&tcon->num_posixmkdirs);
1126 else
1127 cifs_stats_inc(&tcon->num_posixopens);
Steve French2dd29d32007-04-23 22:07:35 +00001128
1129 if (rc == -EAGAIN)
1130 goto PsxCreat;
1131
Steve French50c2f752007-07-13 00:33:32 +00001132 return rc;
Steve French2dd29d32007-04-23 22:07:35 +00001133}
1134
Steve Frencha9d02ad2005-08-24 23:06:05 -07001135static __u16 convert_disposition(int disposition)
1136{
1137 __u16 ofun = 0;
1138
1139 switch (disposition) {
1140 case FILE_SUPERSEDE:
1141 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1142 break;
1143 case FILE_OPEN:
1144 ofun = SMBOPEN_OAPPEND;
1145 break;
1146 case FILE_CREATE:
1147 ofun = SMBOPEN_OCREATE;
1148 break;
1149 case FILE_OPEN_IF:
1150 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1151 break;
1152 case FILE_OVERWRITE:
1153 ofun = SMBOPEN_OTRUNC;
1154 break;
1155 case FILE_OVERWRITE_IF:
1156 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1157 break;
1158 default:
Joe Perchesb6b38f72010-04-21 03:50:45 +00001159 cFYI(1, "unknown disposition %d", disposition);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001160 ofun = SMBOPEN_OAPPEND; /* regular open */
1161 }
1162 return ofun;
1163}
1164
Jeff Layton35fc37d2008-05-14 10:22:03 -07001165static int
1166access_flags_to_smbopen_mode(const int access_flags)
1167{
1168 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1169
1170 if (masked_flags == GENERIC_READ)
1171 return SMBOPEN_READ;
1172 else if (masked_flags == GENERIC_WRITE)
1173 return SMBOPEN_WRITE;
1174
1175 /* just go for read/write */
1176 return SMBOPEN_READWRITE;
1177}
1178
Steve Frencha9d02ad2005-08-24 23:06:05 -07001179int
Steve French96daf2b2011-05-27 04:34:02 +00001180SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001181 const char *fileName, const int openDisposition,
Steve Frenchad7a2922008-02-07 23:25:02 +00001182 const int access_flags, const int create_options, __u16 *netfid,
1183 int *pOplock, FILE_ALL_INFO *pfile_info,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001184 const struct nls_table *nls_codepage, int remap)
1185{
1186 int rc = -EACCES;
1187 OPENX_REQ *pSMB = NULL;
1188 OPENX_RSP *pSMBr = NULL;
1189 int bytes_returned;
1190 int name_len;
1191 __u16 count;
1192
1193OldOpenRetry:
1194 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1195 (void **) &pSMBr);
1196 if (rc)
1197 return rc;
1198
1199 pSMB->AndXCommand = 0xFF; /* none */
1200
1201 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1202 count = 1; /* account for one byte pad to word boundary */
1203 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06001204 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1205 fileName, PATH_MAX, nls_codepage, remap);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001206 name_len++; /* trailing null */
1207 name_len *= 2;
1208 } else { /* BB improve check for buffer overruns BB */
1209 count = 0; /* no pad */
1210 name_len = strnlen(fileName, PATH_MAX);
1211 name_len++; /* trailing null */
1212 strncpy(pSMB->fileName, fileName, name_len);
1213 }
1214 if (*pOplock & REQ_OPLOCK)
1215 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001216 else if (*pOplock & REQ_BATCHOPLOCK)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001217 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001218
Steve Frencha9d02ad2005-08-24 23:06:05 -07001219 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
Jeff Layton35fc37d2008-05-14 10:22:03 -07001220 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001221 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1222 /* set file as system file if special file such
1223 as fifo and server expecting SFU style and
1224 no Unix extensions */
1225
Steve French790fe572007-07-07 19:25:05 +00001226 if (create_options & CREATE_OPTION_SPECIAL)
1227 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
Steve Frenchad7a2922008-02-07 23:25:02 +00001228 else /* BB FIXME BB */
1229 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001230
Jeff Layton67750fb2008-05-09 22:28:02 +00001231 if (create_options & CREATE_OPTION_READONLY)
1232 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001233
1234 /* BB FIXME BB */
Steve French50c2f752007-07-13 00:33:32 +00001235/* pSMB->CreateOptions = cpu_to_le32(create_options &
1236 CREATE_OPTIONS_MASK); */
Steve Frencha9d02ad2005-08-24 23:06:05 -07001237 /* BB FIXME END BB */
Steve French3e87d802005-09-18 20:49:21 -07001238
1239 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
Steve French70ca7342005-09-22 16:32:06 -07001240 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001241 count += name_len;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001242 inc_rfc1001_len(pSMB, count);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001243
1244 pSMB->ByteCount = cpu_to_le16(count);
1245 /* long_op set to 1 to allow for oplock break timeouts */
1246 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Jeff Layton77499812011-01-11 07:24:23 -05001247 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001248 cifs_stats_inc(&tcon->num_opens);
1249 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001250 cFYI(1, "Error in Open = %d", rc);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001251 } else {
1252 /* BB verify if wct == 15 */
1253
Steve French582d21e2008-05-13 04:54:12 +00001254/* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
Steve Frencha9d02ad2005-08-24 23:06:05 -07001255
1256 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1257 /* Let caller know file was created so we can set the mode. */
1258 /* Do we care about the CreateAction in any other cases? */
1259 /* BB FIXME BB */
Steve French790fe572007-07-07 19:25:05 +00001260/* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001261 *pOplock |= CIFS_CREATE_ACTION; */
1262 /* BB FIXME END */
1263
Steve French790fe572007-07-07 19:25:05 +00001264 if (pfile_info) {
Steve Frencha9d02ad2005-08-24 23:06:05 -07001265 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1266 pfile_info->LastAccessTime = 0; /* BB fixme */
1267 pfile_info->LastWriteTime = 0; /* BB fixme */
1268 pfile_info->ChangeTime = 0; /* BB fixme */
Steve French70ca7342005-09-22 16:32:06 -07001269 pfile_info->Attributes =
Steve French50c2f752007-07-13 00:33:32 +00001270 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001271 /* the file_info buf is endian converted by caller */
Steve French70ca7342005-09-22 16:32:06 -07001272 pfile_info->AllocationSize =
1273 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1274 pfile_info->EndOfFile = pfile_info->AllocationSize;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001275 pfile_info->NumberOfLinks = cpu_to_le32(1);
Jeff Layton9a8165f2008-10-17 21:03:20 -04001276 pfile_info->DeletePending = 0;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001277 }
1278 }
1279
1280 cifs_buf_release(pSMB);
1281 if (rc == -EAGAIN)
1282 goto OldOpenRetry;
1283 return rc;
1284}
1285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286int
Steve French96daf2b2011-05-27 04:34:02 +00001287CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 const char *fileName, const int openDisposition,
Steve Frenchad7a2922008-02-07 23:25:02 +00001289 const int access_flags, const int create_options, __u16 *netfid,
1290 int *pOplock, FILE_ALL_INFO *pfile_info,
Steve French737b7582005-04-28 22:41:06 -07001291 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292{
1293 int rc = -EACCES;
1294 OPEN_REQ *pSMB = NULL;
1295 OPEN_RSP *pSMBr = NULL;
1296 int bytes_returned;
1297 int name_len;
1298 __u16 count;
1299
1300openRetry:
1301 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1302 (void **) &pSMBr);
1303 if (rc)
1304 return rc;
1305
1306 pSMB->AndXCommand = 0xFF; /* none */
1307
1308 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1309 count = 1; /* account for one byte pad to word boundary */
1310 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06001311 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1312 fileName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 name_len++; /* trailing null */
1314 name_len *= 2;
1315 pSMB->NameLength = cpu_to_le16(name_len);
Steve French09d1db52005-04-28 22:41:08 -07001316 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 count = 0; /* no pad */
1318 name_len = strnlen(fileName, PATH_MAX);
1319 name_len++; /* trailing null */
1320 pSMB->NameLength = cpu_to_le16(name_len);
1321 strncpy(pSMB->fileName, fileName, name_len);
1322 }
1323 if (*pOplock & REQ_OPLOCK)
1324 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001325 else if (*pOplock & REQ_BATCHOPLOCK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1328 pSMB->AllocationSize = 0;
Steve Frencheda3c022005-07-21 15:20:28 -07001329 /* set file as system file if special file such
1330 as fifo and server expecting SFU style and
1331 no Unix extensions */
Steve French790fe572007-07-07 19:25:05 +00001332 if (create_options & CREATE_OPTION_SPECIAL)
Steve Frencheda3c022005-07-21 15:20:28 -07001333 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1334 else
1335 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
Jeff Layton67750fb2008-05-09 22:28:02 +00001336
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 /* XP does not handle ATTR_POSIX_SEMANTICS */
1338 /* but it helps speed up case sensitive checks for other
1339 servers such as Samba */
1340 if (tcon->ses->capabilities & CAP_UNIX)
1341 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1342
Jeff Layton67750fb2008-05-09 22:28:02 +00001343 if (create_options & CREATE_OPTION_READONLY)
1344 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1345
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1347 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
Steve Frencheda3c022005-07-21 15:20:28 -07001348 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
Steve French09d1db52005-04-28 22:41:08 -07001349 /* BB Expirement with various impersonation levels and verify */
1350 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 pSMB->SecurityFlags =
1352 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1353
1354 count += name_len;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001355 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 pSMB->ByteCount = cpu_to_le16(count);
1358 /* long_op set to 1 to allow for oplock break timeouts */
1359 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Jeff Layton77499812011-01-11 07:24:23 -05001360 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07001361 cifs_stats_inc(&tcon->num_opens);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001363 cFYI(1, "Error in Open = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 } else {
Steve French09d1db52005-04-28 22:41:08 -07001365 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1367 /* Let caller know file was created so we can set the mode. */
1368 /* Do we care about the CreateAction in any other cases? */
Steve French790fe572007-07-07 19:25:05 +00001369 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
Steve French50c2f752007-07-13 00:33:32 +00001370 *pOplock |= CIFS_CREATE_ACTION;
Steve French790fe572007-07-07 19:25:05 +00001371 if (pfile_info) {
Steve French61e74802008-12-03 00:57:54 +00001372 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1373 36 /* CreationTime to Attributes */);
1374 /* the file_info buf is endian converted by caller */
1375 pfile_info->AllocationSize = pSMBr->AllocationSize;
1376 pfile_info->EndOfFile = pSMBr->EndOfFile;
1377 pfile_info->NumberOfLinks = cpu_to_le32(1);
1378 pfile_info->DeletePending = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 }
Steve Frencha5a2b482005-08-20 21:42:53 -07001381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 cifs_buf_release(pSMB);
1383 if (rc == -EAGAIN)
1384 goto openRetry;
1385 return rc;
1386}
1387
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001388struct cifs_readdata *
1389cifs_readdata_alloc(unsigned int nr_pages)
1390{
1391 struct cifs_readdata *rdata;
1392
1393 /* readdata + 1 kvec for each page */
1394 rdata = kzalloc(sizeof(*rdata) +
1395 sizeof(struct kvec) * nr_pages, GFP_KERNEL);
1396 if (rdata != NULL) {
1397 INIT_WORK(&rdata->work, cifs_readv_complete);
1398 INIT_LIST_HEAD(&rdata->pages);
1399 }
1400 return rdata;
1401}
1402
1403void
1404cifs_readdata_free(struct cifs_readdata *rdata)
1405{
1406 cifsFileInfo_put(rdata->cfile);
1407 kfree(rdata);
1408}
1409
1410/*
1411 * Discard any remaining data in the current SMB. To do this, we borrow the
1412 * current bigbuf.
1413 */
1414static int
1415cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1416{
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001417 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001418 int remaining = rfclen + 4 - server->total_read;
1419 struct cifs_readdata *rdata = mid->callback_data;
1420
1421 while (remaining > 0) {
1422 int length;
1423
1424 length = cifs_read_from_socket(server, server->bigbuf,
1425 min_t(unsigned int, remaining,
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001426 CIFSMaxBufSize + max_header_size()));
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001427 if (length < 0)
1428 return length;
1429 server->total_read += length;
1430 remaining -= length;
1431 }
1432
1433 dequeue_mid(mid, rdata->result);
1434 return 0;
1435}
1436
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001437static inline size_t
1438read_rsp_size(void)
1439{
1440 return sizeof(READ_RSP);
1441}
1442
1443static inline unsigned int
1444read_data_offset(char *buf)
1445{
1446 READ_RSP *rsp = (READ_RSP *)buf;
1447 return le16_to_cpu(rsp->DataOffset);
1448}
1449
1450static inline unsigned int
1451read_data_length(char *buf)
1452{
1453 READ_RSP *rsp = (READ_RSP *)buf;
1454 return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
1455 le16_to_cpu(rsp->DataLength);
1456}
1457
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001458static int
1459cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1460{
1461 int length, len;
1462 unsigned int data_offset, remaining, data_len;
1463 struct cifs_readdata *rdata = mid->callback_data;
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001464 char *buf = server->smallbuf;
1465 unsigned int buflen = get_rfc1002_length(buf) + 4;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001466 u64 eof;
1467 pgoff_t eof_index;
1468 struct page *page, *tpage;
1469
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001470 cFYI(1, "%s: mid=%llu offset=%llu bytes=%u", __func__,
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001471 mid->mid, rdata->offset, rdata->bytes);
1472
1473 /*
1474 * read the rest of READ_RSP header (sans Data array), or whatever we
1475 * can if there's not enough data. At this point, we've read down to
1476 * the Mid.
1477 */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001478 len = min_t(unsigned int, buflen, read_rsp_size()) - header_size() + 1;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001479
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001480 rdata->iov[0].iov_base = buf + header_size() - 1;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001481 rdata->iov[0].iov_len = len;
1482
1483 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1484 if (length < 0)
1485 return length;
1486 server->total_read += length;
1487
1488 /* Was the SMB read successful? */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001489 rdata->result = map_smb_to_linux_error(buf, false);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001490 if (rdata->result != 0) {
1491 cFYI(1, "%s: server returned error %d", __func__,
1492 rdata->result);
1493 return cifs_readv_discard(server, mid);
1494 }
1495
1496 /* Is there enough to get to the rest of the READ_RSP header? */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001497 if (server->total_read < read_rsp_size()) {
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001498 cFYI(1, "%s: server returned short header. got=%u expected=%zu",
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001499 __func__, server->total_read, read_rsp_size());
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001500 rdata->result = -EIO;
1501 return cifs_readv_discard(server, mid);
1502 }
1503
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001504 data_offset = read_data_offset(buf) + 4;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001505 if (data_offset < server->total_read) {
1506 /*
1507 * win2k8 sometimes sends an offset of 0 when the read
1508 * is beyond the EOF. Treat it as if the data starts just after
1509 * the header.
1510 */
1511 cFYI(1, "%s: data offset (%u) inside read response header",
1512 __func__, data_offset);
1513 data_offset = server->total_read;
1514 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1515 /* data_offset is beyond the end of smallbuf */
1516 cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
1517 __func__, data_offset);
1518 rdata->result = -EIO;
1519 return cifs_readv_discard(server, mid);
1520 }
1521
1522 cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
1523 server->total_read, data_offset);
1524
1525 len = data_offset - server->total_read;
1526 if (len > 0) {
1527 /* read any junk before data into the rest of smallbuf */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001528 rdata->iov[0].iov_base = buf + server->total_read;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001529 rdata->iov[0].iov_len = len;
1530 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1531 if (length < 0)
1532 return length;
1533 server->total_read += length;
1534 }
1535
1536 /* set up first iov for signature check */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001537 rdata->iov[0].iov_base = buf;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001538 rdata->iov[0].iov_len = server->total_read;
1539 cFYI(1, "0: iov_base=%p iov_len=%zu",
1540 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1541
1542 /* how much data is in the response? */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001543 data_len = read_data_length(buf);
1544 if (data_offset + data_len > buflen) {
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001545 /* data_len is corrupt -- discard frame */
1546 rdata->result = -EIO;
1547 return cifs_readv_discard(server, mid);
1548 }
1549
1550 /* marshal up the page array */
1551 len = 0;
1552 remaining = data_len;
1553 rdata->nr_iov = 1;
1554
1555 /* determine the eof that the server (probably) has */
1556 eof = CIFS_I(rdata->mapping->host)->server_eof;
1557 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
1558 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
1559
1560 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1561 if (remaining >= PAGE_CACHE_SIZE) {
1562 /* enough data to fill the page */
1563 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1564 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
1565 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1566 rdata->nr_iov, page->index,
1567 rdata->iov[rdata->nr_iov].iov_base,
1568 rdata->iov[rdata->nr_iov].iov_len);
1569 ++rdata->nr_iov;
1570 len += PAGE_CACHE_SIZE;
1571 remaining -= PAGE_CACHE_SIZE;
1572 } else if (remaining > 0) {
1573 /* enough for partial page, fill and zero the rest */
1574 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1575 rdata->iov[rdata->nr_iov].iov_len = remaining;
1576 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1577 rdata->nr_iov, page->index,
1578 rdata->iov[rdata->nr_iov].iov_base,
1579 rdata->iov[rdata->nr_iov].iov_len);
1580 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
1581 '\0', PAGE_CACHE_SIZE - remaining);
1582 ++rdata->nr_iov;
1583 len += remaining;
1584 remaining = 0;
1585 } else if (page->index > eof_index) {
1586 /*
1587 * The VFS will not try to do readahead past the
1588 * i_size, but it's possible that we have outstanding
1589 * writes with gaps in the middle and the i_size hasn't
1590 * caught up yet. Populate those with zeroed out pages
1591 * to prevent the VFS from repeatedly attempting to
1592 * fill them until the writes are flushed.
1593 */
1594 zero_user(page, 0, PAGE_CACHE_SIZE);
1595 list_del(&page->lru);
1596 lru_cache_add_file(page);
1597 flush_dcache_page(page);
1598 SetPageUptodate(page);
1599 unlock_page(page);
1600 page_cache_release(page);
1601 } else {
1602 /* no need to hold page hostage */
1603 list_del(&page->lru);
1604 lru_cache_add_file(page);
1605 unlock_page(page);
1606 page_cache_release(page);
1607 }
1608 }
1609
1610 /* issue the read if we have any iovecs left to fill */
1611 if (rdata->nr_iov > 1) {
1612 length = cifs_readv_from_socket(server, &rdata->iov[1],
1613 rdata->nr_iov - 1, len);
1614 if (length < 0)
1615 return length;
1616 server->total_read += length;
1617 } else {
1618 length = 0;
1619 }
1620
1621 rdata->bytes = length;
1622
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001623 cFYI(1, "total_read=%u buflen=%u remaining=%u", server->total_read,
1624 buflen, remaining);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001625
1626 /* discard anything left over */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001627 if (server->total_read < buflen)
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001628 return cifs_readv_discard(server, mid);
1629
1630 dequeue_mid(mid, false);
1631 return length;
1632}
1633
1634static void
1635cifs_readv_complete(struct work_struct *work)
1636{
1637 struct cifs_readdata *rdata = container_of(work,
1638 struct cifs_readdata, work);
1639 struct page *page, *tpage;
1640
1641 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1642 list_del(&page->lru);
1643 lru_cache_add_file(page);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001644
1645 if (rdata->result == 0) {
Pavel Shilovskya2d6b6c2011-10-21 10:14:04 +04001646 kunmap(page);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001647 flush_dcache_page(page);
1648 SetPageUptodate(page);
1649 }
1650
1651 unlock_page(page);
1652
1653 if (rdata->result == 0)
1654 cifs_readpage_to_fscache(rdata->mapping->host, page);
1655
1656 page_cache_release(page);
1657 }
1658 cifs_readdata_free(rdata);
1659}
1660
1661static void
1662cifs_readv_callback(struct mid_q_entry *mid)
1663{
1664 struct cifs_readdata *rdata = mid->callback_data;
1665 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1666 struct TCP_Server_Info *server = tcon->ses->server;
1667
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001668 cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
1669 mid->mid, mid->mid_state, rdata->result, rdata->bytes);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001670
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001671 switch (mid->mid_state) {
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001672 case MID_RESPONSE_RECEIVED:
1673 /* result already set, check signature */
1674 if (server->sec_mode &
1675 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1676 if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
1677 server, mid->sequence_number + 1))
1678 cERROR(1, "Unexpected SMB signature");
1679 }
1680 /* FIXME: should this be counted toward the initiating task? */
1681 task_io_account_read(rdata->bytes);
1682 cifs_stats_bytes_read(tcon, rdata->bytes);
1683 break;
1684 case MID_REQUEST_SUBMITTED:
1685 case MID_RETRY_NEEDED:
1686 rdata->result = -EAGAIN;
1687 break;
1688 default:
1689 rdata->result = -EIO;
1690 }
1691
Jeff Laytonda472fc2012-03-23 14:40:53 -04001692 queue_work(cifsiod_wq, &rdata->work);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001693 DeleteMidQEntry(mid);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04001694 cifs_add_credits(server, 1);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001695}
1696
1697/* cifs_async_readv - send an async write, and set up mid to handle result */
1698int
1699cifs_async_readv(struct cifs_readdata *rdata)
1700{
1701 int rc;
1702 READ_REQ *smb = NULL;
1703 int wct;
1704 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1705
1706 cFYI(1, "%s: offset=%llu bytes=%u", __func__,
1707 rdata->offset, rdata->bytes);
1708
1709 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1710 wct = 12;
1711 else {
1712 wct = 10; /* old style read */
1713 if ((rdata->offset >> 32) > 0) {
1714 /* can not handle this big offset for old */
1715 return -EIO;
1716 }
1717 }
1718
1719 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1720 if (rc)
1721 return rc;
1722
1723 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1724 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1725
1726 smb->AndXCommand = 0xFF; /* none */
1727 smb->Fid = rdata->cfile->netfid;
1728 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1729 if (wct == 12)
1730 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1731 smb->Remaining = 0;
1732 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1733 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1734 if (wct == 12)
1735 smb->ByteCount = 0;
1736 else {
1737 /* old style read */
1738 struct smb_com_readx_req *smbr =
1739 (struct smb_com_readx_req *)smb;
1740 smbr->ByteCount = 0;
1741 }
1742
1743 /* 4 for RFC1001 length + 1 for BCC */
1744 rdata->iov[0].iov_base = smb;
1745 rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1746
1747 rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
1748 cifs_readv_receive, cifs_readv_callback,
1749 rdata, false);
1750
1751 if (rc == 0)
1752 cifs_stats_inc(&tcon->num_reads);
1753
1754 cifs_small_buf_release(smb);
1755 return rc;
1756}
1757
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758int
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001759CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
Steve French50c2f752007-07-13 00:33:32 +00001760 char **buf, int *pbuf_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761{
1762 int rc = -EACCES;
1763 READ_REQ *pSMB = NULL;
1764 READ_RSP *pSMBr = NULL;
1765 char *pReadData = NULL;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001766 int wct;
Steve Frenchec637e32005-12-12 20:53:18 -08001767 int resp_buf_type = 0;
1768 struct kvec iov[1];
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001769 __u32 pid = io_parms->pid;
1770 __u16 netfid = io_parms->netfid;
1771 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001772 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001773 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
Joe Perchesb6b38f72010-04-21 03:50:45 +00001775 cFYI(1, "Reading %d bytes on fid %d", count, netfid);
Steve French790fe572007-07-07 19:25:05 +00001776 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001777 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001778 else {
Steve Frenchbfa0d752005-08-31 21:50:37 -07001779 wct = 10; /* old style read */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001780 if ((offset >> 32) > 0) {
Steve French4c3130e2008-12-09 00:28:16 +00001781 /* can not handle this big offset for old */
1782 return -EIO;
1783 }
1784 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
1786 *nbytes = 0;
Steve Frenchec637e32005-12-12 20:53:18 -08001787 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 if (rc)
1789 return rc;
1790
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001791 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1792 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 /* tcon and ses pointer are checked in smb_init */
1795 if (tcon->ses->server == NULL)
1796 return -ECONNABORTED;
1797
Steve Frenchec637e32005-12-12 20:53:18 -08001798 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 pSMB->Fid = netfid;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001800 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001801 if (wct == 12)
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001802 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve Frenchbfa0d752005-08-31 21:50:37 -07001803
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 pSMB->Remaining = 0;
1805 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1806 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
Steve French790fe572007-07-07 19:25:05 +00001807 if (wct == 12)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001808 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1809 else {
1810 /* old style read */
Steve French50c2f752007-07-13 00:33:32 +00001811 struct smb_com_readx_req *pSMBW =
Steve Frenchbfa0d752005-08-31 21:50:37 -07001812 (struct smb_com_readx_req *)pSMB;
Steve Frenchec637e32005-12-12 20:53:18 -08001813 pSMBW->ByteCount = 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001814 }
Steve Frenchec637e32005-12-12 20:53:18 -08001815
1816 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001817 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve Frencha761ac52007-10-18 21:45:27 +00001818 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
Jeff Layton77499812011-01-11 07:24:23 -05001819 &resp_buf_type, CIFS_LOG_ERROR);
Steve Frencha4544342005-08-24 13:59:35 -07001820 cifs_stats_inc(&tcon->num_reads);
Steve Frenchec637e32005-12-12 20:53:18 -08001821 pSMBr = (READ_RSP *)iov[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001823 cERROR(1, "Send error in read = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 } else {
1825 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1826 data_length = data_length << 16;
1827 data_length += le16_to_cpu(pSMBr->DataLength);
1828 *nbytes = data_length;
1829
1830 /*check that DataLength would not go beyond end of SMB */
Steve Frenchec637e32005-12-12 20:53:18 -08001831 if ((data_length > CIFSMaxBufSize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 || (data_length > count)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001833 cFYI(1, "bad length %d for count %d",
1834 data_length, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 rc = -EIO;
1836 *nbytes = 0;
1837 } else {
Steve Frenchec637e32005-12-12 20:53:18 -08001838 pReadData = (char *) (&pSMBr->hdr.Protocol) +
Steve French26f57362007-08-30 22:09:15 +00001839 le16_to_cpu(pSMBr->DataOffset);
1840/* if (rc = copy_to_user(buf, pReadData, data_length)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001841 cERROR(1, "Faulting on read rc = %d",rc);
Steve French50c2f752007-07-13 00:33:32 +00001842 rc = -EFAULT;
Steve French26f57362007-08-30 22:09:15 +00001843 }*/ /* can not use copy_to_user when using page cache*/
Steve French790fe572007-07-07 19:25:05 +00001844 if (*buf)
Steve French50c2f752007-07-13 00:33:32 +00001845 memcpy(*buf, pReadData, data_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 }
1847 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848
Steve French4b8f9302006-02-26 16:41:18 +00001849/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00001850 if (*buf) {
1851 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001852 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001853 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001854 cifs_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001855 } else if (resp_buf_type != CIFS_NO_BUFFER) {
Steve French50c2f752007-07-13 00:33:32 +00001856 /* return buffer to caller to free */
1857 *buf = iov[0].iov_base;
Steve French790fe572007-07-07 19:25:05 +00001858 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001859 *pbuf_type = CIFS_SMALL_BUFFER;
Steve French790fe572007-07-07 19:25:05 +00001860 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001861 *pbuf_type = CIFS_LARGE_BUFFER;
Steve French6cec2ae2006-02-22 17:31:52 -06001862 } /* else no valid buffer on return - leave as null */
Steve Frenchec637e32005-12-12 20:53:18 -08001863
1864 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 since file handle passed in no longer valid */
1866 return rc;
1867}
1868
Steve Frenchec637e32005-12-12 20:53:18 -08001869
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870int
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001871CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
1872 unsigned int *nbytes, const char *buf,
Steve French50c2f752007-07-13 00:33:32 +00001873 const char __user *ubuf, const int long_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874{
1875 int rc = -EACCES;
1876 WRITE_REQ *pSMB = NULL;
1877 WRITE_RSP *pSMBr = NULL;
Steve French1c955182005-08-30 20:58:07 -07001878 int bytes_returned, wct;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 __u32 bytes_sent;
1880 __u16 byte_count;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001881 __u32 pid = io_parms->pid;
1882 __u16 netfid = io_parms->netfid;
1883 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001884 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001885 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886
Steve Frencha24e2d72010-04-03 17:20:21 +00001887 *nbytes = 0;
1888
Joe Perchesb6b38f72010-04-21 03:50:45 +00001889 /* cFYI(1, "write at %lld %d bytes", offset, count);*/
Steve French790fe572007-07-07 19:25:05 +00001890 if (tcon->ses == NULL)
Steve French1c955182005-08-30 20:58:07 -07001891 return -ECONNABORTED;
1892
Steve French790fe572007-07-07 19:25:05 +00001893 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve French1c955182005-08-30 20:58:07 -07001894 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00001895 else {
Steve French1c955182005-08-30 20:58:07 -07001896 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001897 if ((offset >> 32) > 0) {
1898 /* can not handle big offset for old srv */
1899 return -EIO;
1900 }
1901 }
Steve French1c955182005-08-30 20:58:07 -07001902
1903 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 (void **) &pSMBr);
1905 if (rc)
1906 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001907
1908 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1909 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 /* tcon and ses pointer are checked in smb_init */
1912 if (tcon->ses->server == NULL)
1913 return -ECONNABORTED;
1914
1915 pSMB->AndXCommand = 0xFF; /* none */
1916 pSMB->Fid = netfid;
1917 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001918 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001919 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve French50c2f752007-07-13 00:33:32 +00001920
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 pSMB->Reserved = 0xFFFFFFFF;
1922 pSMB->WriteMode = 0;
1923 pSMB->Remaining = 0;
1924
Steve French50c2f752007-07-13 00:33:32 +00001925 /* Can increase buffer size if buffer is big enough in some cases ie we
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 can send more if LARGE_WRITE_X capability returned by the server and if
1927 our buffer is big enough or if we convert to iovecs on socket writes
1928 and eliminate the copy to the CIFS buffer */
Steve French790fe572007-07-07 19:25:05 +00001929 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1931 } else {
1932 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1933 & ~0xFF;
1934 }
1935
1936 if (bytes_sent > count)
1937 bytes_sent = count;
1938 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00001939 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Steve French790fe572007-07-07 19:25:05 +00001940 if (buf)
Steve French61e74802008-12-03 00:57:54 +00001941 memcpy(pSMB->Data, buf, bytes_sent);
Steve French790fe572007-07-07 19:25:05 +00001942 else if (ubuf) {
1943 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 cifs_buf_release(pSMB);
1945 return -EFAULT;
1946 }
Steve Frenche30dcf32005-09-20 20:49:16 -07001947 } else if (count != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 /* No buffer */
1949 cifs_buf_release(pSMB);
1950 return -EINVAL;
Steve Frenche30dcf32005-09-20 20:49:16 -07001951 } /* else setting file size with write of zero bytes */
Steve French790fe572007-07-07 19:25:05 +00001952 if (wct == 14)
Steve Frenche30dcf32005-09-20 20:49:16 -07001953 byte_count = bytes_sent + 1; /* pad */
Steve Frenchad7a2922008-02-07 23:25:02 +00001954 else /* wct == 12 */
Steve Frenche30dcf32005-09-20 20:49:16 -07001955 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
Steve Frenchad7a2922008-02-07 23:25:02 +00001956
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1958 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001959 inc_rfc1001_len(pSMB, byte_count);
Steve French1c955182005-08-30 20:58:07 -07001960
Steve French790fe572007-07-07 19:25:05 +00001961 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001962 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00001963 else { /* old style write has byte count 4 bytes earlier
1964 so 4 bytes pad */
1965 struct smb_com_writex_req *pSMBW =
Steve French1c955182005-08-30 20:58:07 -07001966 (struct smb_com_writex_req *)pSMB;
1967 pSMBW->ByteCount = cpu_to_le16(byte_count);
1968 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969
1970 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1971 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
Steve Frencha4544342005-08-24 13:59:35 -07001972 cifs_stats_inc(&tcon->num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00001974 cFYI(1, "Send error in write = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 } else {
1976 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1977 *nbytes = (*nbytes) << 16;
1978 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05301979
1980 /*
1981 * Mask off high 16 bits when bytes written as returned by the
1982 * server is greater than bytes requested by the client. Some
1983 * OS/2 servers are known to set incorrect CountHigh values.
1984 */
1985 if (*nbytes > count)
1986 *nbytes &= 0xFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 }
1988
1989 cifs_buf_release(pSMB);
1990
Steve French50c2f752007-07-13 00:33:32 +00001991 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 since file handle passed in no longer valid */
1993
1994 return rc;
1995}
1996
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001997void
1998cifs_writedata_release(struct kref *refcount)
1999{
2000 struct cifs_writedata *wdata = container_of(refcount,
2001 struct cifs_writedata, refcount);
2002
2003 if (wdata->cfile)
2004 cifsFileInfo_put(wdata->cfile);
2005
2006 kfree(wdata);
2007}
2008
2009/*
2010 * Write failed with a retryable error. Resend the write request. It's also
2011 * possible that the page was redirtied so re-clean the page.
2012 */
2013static void
2014cifs_writev_requeue(struct cifs_writedata *wdata)
2015{
2016 int i, rc;
2017 struct inode *inode = wdata->cfile->dentry->d_inode;
2018
2019 for (i = 0; i < wdata->nr_pages; i++) {
2020 lock_page(wdata->pages[i]);
2021 clear_page_dirty_for_io(wdata->pages[i]);
2022 }
2023
2024 do {
2025 rc = cifs_async_writev(wdata);
2026 } while (rc == -EAGAIN);
2027
2028 for (i = 0; i < wdata->nr_pages; i++) {
2029 if (rc != 0)
2030 SetPageError(wdata->pages[i]);
2031 unlock_page(wdata->pages[i]);
2032 }
2033
2034 mapping_set_error(inode->i_mapping, rc);
2035 kref_put(&wdata->refcount, cifs_writedata_release);
2036}
2037
Jeff Laytonc2e87642012-03-23 14:40:55 -04002038void
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002039cifs_writev_complete(struct work_struct *work)
2040{
2041 struct cifs_writedata *wdata = container_of(work,
2042 struct cifs_writedata, work);
2043 struct inode *inode = wdata->cfile->dentry->d_inode;
2044 int i = 0;
2045
2046 if (wdata->result == 0) {
2047 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2048 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2049 wdata->bytes);
2050 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2051 return cifs_writev_requeue(wdata);
2052
2053 for (i = 0; i < wdata->nr_pages; i++) {
2054 struct page *page = wdata->pages[i];
2055 if (wdata->result == -EAGAIN)
2056 __set_page_dirty_nobuffers(page);
2057 else if (wdata->result < 0)
2058 SetPageError(page);
2059 end_page_writeback(page);
2060 page_cache_release(page);
2061 }
2062 if (wdata->result != -EAGAIN)
2063 mapping_set_error(inode->i_mapping, wdata->result);
2064 kref_put(&wdata->refcount, cifs_writedata_release);
2065}
2066
2067struct cifs_writedata *
Jeff Laytonc2e87642012-03-23 14:40:55 -04002068cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002069{
2070 struct cifs_writedata *wdata;
2071
2072 /* this would overflow */
2073 if (nr_pages == 0) {
2074 cERROR(1, "%s: called with nr_pages == 0!", __func__);
2075 return NULL;
2076 }
2077
2078 /* writedata + number of page pointers */
2079 wdata = kzalloc(sizeof(*wdata) +
2080 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
2081 if (wdata != NULL) {
Jeff Laytonc2e87642012-03-23 14:40:55 -04002082 INIT_WORK(&wdata->work, complete);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002083 kref_init(&wdata->refcount);
2084 }
2085 return wdata;
2086}
2087
2088/*
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04002089 * Check the mid_state and signature on received buffer (if any), and queue the
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002090 * workqueue completion task.
2091 */
2092static void
2093cifs_writev_callback(struct mid_q_entry *mid)
2094{
2095 struct cifs_writedata *wdata = mid->callback_data;
Steve French96daf2b2011-05-27 04:34:02 +00002096 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002097 unsigned int written;
2098 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2099
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04002100 switch (mid->mid_state) {
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002101 case MID_RESPONSE_RECEIVED:
2102 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2103 if (wdata->result != 0)
2104 break;
2105
2106 written = le16_to_cpu(smb->CountHigh);
2107 written <<= 16;
2108 written += le16_to_cpu(smb->Count);
2109 /*
2110 * Mask off high 16 bits when bytes written as returned
2111 * by the server is greater than bytes requested by the
2112 * client. OS/2 servers are known to set incorrect
2113 * CountHigh values.
2114 */
2115 if (written > wdata->bytes)
2116 written &= 0xFFFF;
2117
2118 if (written < wdata->bytes)
2119 wdata->result = -ENOSPC;
2120 else
2121 wdata->bytes = written;
2122 break;
2123 case MID_REQUEST_SUBMITTED:
2124 case MID_RETRY_NEEDED:
2125 wdata->result = -EAGAIN;
2126 break;
2127 default:
2128 wdata->result = -EIO;
2129 break;
2130 }
2131
Jeff Laytonda472fc2012-03-23 14:40:53 -04002132 queue_work(cifsiod_wq, &wdata->work);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002133 DeleteMidQEntry(mid);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002134 cifs_add_credits(tcon->ses->server, 1);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002135}
2136
2137/* cifs_async_writev - send an async write, and set up mid to handle result */
2138int
2139cifs_async_writev(struct cifs_writedata *wdata)
2140{
2141 int i, rc = -EACCES;
2142 WRITE_REQ *smb = NULL;
2143 int wct;
Steve French96daf2b2011-05-27 04:34:02 +00002144 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002145 struct inode *inode = wdata->cfile->dentry->d_inode;
2146 struct kvec *iov = NULL;
2147
2148 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2149 wct = 14;
2150 } else {
2151 wct = 12;
2152 if (wdata->offset >> 32 > 0) {
2153 /* can not handle big offset for old srv */
2154 return -EIO;
2155 }
2156 }
2157
2158 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2159 if (rc)
2160 goto async_writev_out;
2161
2162 /* 1 iov per page + 1 for header */
2163 iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
2164 if (iov == NULL) {
2165 rc = -ENOMEM;
2166 goto async_writev_out;
2167 }
2168
Jeff Laytonfe5f5d22012-03-23 14:40:55 -04002169 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2170 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002171
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002172 smb->AndXCommand = 0xFF; /* none */
2173 smb->Fid = wdata->cfile->netfid;
2174 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2175 if (wct == 14)
2176 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2177 smb->Reserved = 0xFFFFFFFF;
2178 smb->WriteMode = 0;
2179 smb->Remaining = 0;
2180
2181 smb->DataOffset =
2182 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2183
2184 /* 4 for RFC1001 length + 1 for BCC */
2185 iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2186 iov[0].iov_base = smb;
2187
2188 /* marshal up the pages into iov array */
2189 wdata->bytes = 0;
2190 for (i = 0; i < wdata->nr_pages; i++) {
2191 iov[i + 1].iov_len = min(inode->i_size -
2192 page_offset(wdata->pages[i]),
2193 (loff_t)PAGE_CACHE_SIZE);
2194 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2195 wdata->bytes += iov[i + 1].iov_len;
2196 }
2197
2198 cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
2199
2200 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2201 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2202
2203 if (wct == 14) {
2204 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2205 put_bcc(wdata->bytes + 1, &smb->hdr);
2206 } else {
2207 /* wct == 12 */
2208 struct smb_com_writex_req *smbw =
2209 (struct smb_com_writex_req *)smb;
2210 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2211 put_bcc(wdata->bytes + 5, &smbw->hdr);
2212 iov[0].iov_len += 4; /* pad bigger by four bytes */
2213 }
2214
2215 kref_get(&wdata->refcount);
2216 rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
Jeff Layton44d22d82011-10-19 15:29:49 -04002217 NULL, cifs_writev_callback, wdata, false);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002218
2219 if (rc == 0)
2220 cifs_stats_inc(&tcon->num_writes);
2221 else
2222 kref_put(&wdata->refcount, cifs_writedata_release);
2223
2224 /* send is done, unmap pages */
2225 for (i = 0; i < wdata->nr_pages; i++)
2226 kunmap(wdata->pages[i]);
2227
2228async_writev_out:
2229 cifs_small_buf_release(smb);
2230 kfree(iov);
2231 return rc;
2232}
2233
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002234int
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002235CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
2236 unsigned int *nbytes, struct kvec *iov, int n_vec,
2237 const int long_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238{
2239 int rc = -EACCES;
2240 WRITE_REQ *pSMB = NULL;
Steve Frenchec637e32005-12-12 20:53:18 -08002241 int wct;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002242 int smb_hdr_len;
Steve Frenchec637e32005-12-12 20:53:18 -08002243 int resp_buf_type = 0;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002244 __u32 pid = io_parms->pid;
2245 __u16 netfid = io_parms->netfid;
2246 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00002247 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002248 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002250 *nbytes = 0;
2251
Joe Perchesb6b38f72010-04-21 03:50:45 +00002252 cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
Steve Frenchff7feac2005-11-15 16:45:16 -08002253
Steve French4c3130e2008-12-09 00:28:16 +00002254 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
Steve French8cc64c62005-10-03 13:49:43 -07002255 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00002256 } else {
Steve French8cc64c62005-10-03 13:49:43 -07002257 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00002258 if ((offset >> 32) > 0) {
2259 /* can not handle big offset for old srv */
2260 return -EIO;
2261 }
2262 }
Steve French8cc64c62005-10-03 13:49:43 -07002263 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 if (rc)
2265 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002266
2267 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2268 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2269
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 /* tcon and ses pointer are checked in smb_init */
2271 if (tcon->ses->server == NULL)
2272 return -ECONNABORTED;
2273
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002274 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275 pSMB->Fid = netfid;
2276 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00002277 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002278 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 pSMB->Reserved = 0xFFFFFFFF;
2280 pSMB->WriteMode = 0;
2281 pSMB->Remaining = 0;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002282
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00002284 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
Steve French3e844692005-10-03 13:37:24 -07002286 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2287 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002288 /* header + 1 byte pad */
2289 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
Steve French790fe572007-07-07 19:25:05 +00002290 if (wct == 14)
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002291 inc_rfc1001_len(pSMB, count + 1);
Steve French8cc64c62005-10-03 13:49:43 -07002292 else /* wct == 12 */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002293 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
Steve French790fe572007-07-07 19:25:05 +00002294 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002295 pSMB->ByteCount = cpu_to_le16(count + 1);
2296 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
Steve French50c2f752007-07-13 00:33:32 +00002297 struct smb_com_writex_req *pSMBW =
Steve French8cc64c62005-10-03 13:49:43 -07002298 (struct smb_com_writex_req *)pSMB;
2299 pSMBW->ByteCount = cpu_to_le16(count + 5);
2300 }
Steve French3e844692005-10-03 13:37:24 -07002301 iov[0].iov_base = pSMB;
Steve French790fe572007-07-07 19:25:05 +00002302 if (wct == 14)
Steve Frenchec637e32005-12-12 20:53:18 -08002303 iov[0].iov_len = smb_hdr_len + 4;
2304 else /* wct == 12 pad bigger by four bytes */
2305 iov[0].iov_len = smb_hdr_len + 8;
Steve French50c2f752007-07-13 00:33:32 +00002306
Steve French3e844692005-10-03 13:37:24 -07002307
Steve Frenchec637e32005-12-12 20:53:18 -08002308 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
Steve French133672e2007-11-13 22:41:37 +00002309 long_op);
Steve Frencha4544342005-08-24 13:59:35 -07002310 cifs_stats_inc(&tcon->num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002312 cFYI(1, "Send error Write2 = %d", rc);
Steve French790fe572007-07-07 19:25:05 +00002313 } else if (resp_buf_type == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -08002314 /* presumably this can not happen, but best to be safe */
2315 rc = -EIO;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002316 } else {
Steve Frenchad7a2922008-02-07 23:25:02 +00002317 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002318 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2319 *nbytes = (*nbytes) << 16;
2320 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05302321
2322 /*
2323 * Mask off high 16 bits when bytes written as returned by the
2324 * server is greater than bytes requested by the client. OS/2
2325 * servers are known to set incorrect CountHigh values.
2326 */
2327 if (*nbytes > count)
2328 *nbytes &= 0xFFFF;
Steve French50c2f752007-07-13 00:33:32 +00002329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330
Steve French4b8f9302006-02-26 16:41:18 +00002331/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00002332 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002333 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00002334 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002335 cifs_buf_release(iov[0].iov_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
Steve French50c2f752007-07-13 00:33:32 +00002337 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 since file handle passed in no longer valid */
2339
2340 return rc;
2341}
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002342
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04002343int cifs_lockv(const int xid, struct cifs_tcon *tcon, const __u16 netfid,
2344 const __u8 lock_type, const __u32 num_unlock,
2345 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2346{
2347 int rc = 0;
2348 LOCK_REQ *pSMB = NULL;
2349 struct kvec iov[2];
2350 int resp_buf_type;
2351 __u16 count;
2352
2353 cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
2354
2355 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2356 if (rc)
2357 return rc;
2358
2359 pSMB->Timeout = 0;
2360 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2361 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2362 pSMB->LockType = lock_type;
2363 pSMB->AndXCommand = 0xFF; /* none */
2364 pSMB->Fid = netfid; /* netfid stays le */
2365
2366 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2367 inc_rfc1001_len(pSMB, count);
2368 pSMB->ByteCount = cpu_to_le16(count);
2369
2370 iov[0].iov_base = (char *)pSMB;
2371 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2372 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2373 iov[1].iov_base = (char *)buf;
2374 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2375
2376 cifs_stats_inc(&tcon->num_locks);
2377 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2378 if (rc)
2379 cFYI(1, "Send error in cifs_lockv = %d", rc);
2380
2381 return rc;
2382}
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002383
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384int
Steve French96daf2b2011-05-27 04:34:02 +00002385CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002386 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 const __u64 offset, const __u32 numUnlock,
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002388 const __u32 numLock, const __u8 lockType,
2389 const bool waitFlag, const __u8 oplock_level)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390{
2391 int rc = 0;
2392 LOCK_REQ *pSMB = NULL;
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002393/* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 int bytes_returned;
2395 int timeout = 0;
2396 __u16 count;
2397
Joe Perchesb6b38f72010-04-21 03:50:45 +00002398 cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
Steve French46810cb2005-04-28 22:41:09 -07002399 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2400
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 if (rc)
2402 return rc;
2403
Steve French790fe572007-07-07 19:25:05 +00002404 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
Steve French133672e2007-11-13 22:41:37 +00002405 timeout = CIFS_ASYNC_OP; /* no response expected */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002406 pSMB->Timeout = 0;
Steve French4b18f2a2008-04-29 00:06:05 +00002407 } else if (waitFlag) {
Steve French133672e2007-11-13 22:41:37 +00002408 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2410 } else {
2411 pSMB->Timeout = 0;
2412 }
2413
2414 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2415 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2416 pSMB->LockType = lockType;
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002417 pSMB->OplockLevel = oplock_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 pSMB->AndXCommand = 0xFF; /* none */
2419 pSMB->Fid = smb_file_id; /* netfid stays le */
2420
Steve French790fe572007-07-07 19:25:05 +00002421 if ((numLock != 0) || (numUnlock != 0)) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002422 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 /* BB where to store pid high? */
2424 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2425 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2426 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2427 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2428 count = sizeof(LOCKING_ANDX_RANGE);
2429 } else {
2430 /* oplock break */
2431 count = 0;
2432 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002433 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 pSMB->ByteCount = cpu_to_le16(count);
2435
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002436 if (waitFlag) {
2437 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002438 (struct smb_hdr *) pSMB, &bytes_returned);
Steve French133672e2007-11-13 22:41:37 +00002439 cifs_small_buf_release(pSMB);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002440 } else {
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04002441 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, timeout);
Steve French133672e2007-11-13 22:41:37 +00002442 /* SMB buffer freed by function above */
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002443 }
Steve Frencha4544342005-08-24 13:59:35 -07002444 cifs_stats_inc(&tcon->num_locks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002445 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002446 cFYI(1, "Send error in Lock = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447
Steve French50c2f752007-07-13 00:33:32 +00002448 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 since file handle passed in no longer valid */
2450 return rc;
2451}
2452
2453int
Steve French96daf2b2011-05-27 04:34:02 +00002454CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04002455 const __u16 smb_file_id, const __u32 netpid, const int get_flag,
2456 const __u64 len, struct file_lock *pLockData,
2457 const __u16 lock_type, const bool waitFlag)
Steve French08547b02006-02-28 22:39:25 +00002458{
2459 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2460 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French08547b02006-02-28 22:39:25 +00002461 struct cifs_posix_lock *parm_data;
2462 int rc = 0;
Steve French3a5ff612006-07-14 22:37:11 +00002463 int timeout = 0;
Steve French08547b02006-02-28 22:39:25 +00002464 int bytes_returned = 0;
Steve French133672e2007-11-13 22:41:37 +00002465 int resp_buf_type = 0;
Steve French08547b02006-02-28 22:39:25 +00002466 __u16 params, param_offset, offset, byte_count, count;
Steve French133672e2007-11-13 22:41:37 +00002467 struct kvec iov[1];
Steve French08547b02006-02-28 22:39:25 +00002468
Joe Perchesb6b38f72010-04-21 03:50:45 +00002469 cFYI(1, "Posix Lock");
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002470
Steve French790fe572007-07-07 19:25:05 +00002471 if (pLockData == NULL)
Marcin Slusarzed5f0372008-05-13 04:01:01 +00002472 return -EINVAL;
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002473
Steve French08547b02006-02-28 22:39:25 +00002474 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2475
2476 if (rc)
2477 return rc;
2478
2479 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2480
Steve French50c2f752007-07-13 00:33:32 +00002481 params = 6;
Steve French08547b02006-02-28 22:39:25 +00002482 pSMB->MaxSetupCount = 0;
2483 pSMB->Reserved = 0;
2484 pSMB->Flags = 0;
Steve French08547b02006-02-28 22:39:25 +00002485 pSMB->Reserved2 = 0;
2486 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2487 offset = param_offset + params;
2488
Steve French08547b02006-02-28 22:39:25 +00002489 count = sizeof(struct cifs_posix_lock);
2490 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002491 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Steve French08547b02006-02-28 22:39:25 +00002492 pSMB->SetupCount = 1;
2493 pSMB->Reserved3 = 0;
Steve French790fe572007-07-07 19:25:05 +00002494 if (get_flag)
Steve French08547b02006-02-28 22:39:25 +00002495 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2496 else
2497 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2498 byte_count = 3 /* pad */ + params + count;
2499 pSMB->DataCount = cpu_to_le16(count);
2500 pSMB->ParameterCount = cpu_to_le16(params);
2501 pSMB->TotalDataCount = pSMB->DataCount;
2502 pSMB->TotalParameterCount = pSMB->ParameterCount;
2503 pSMB->ParameterOffset = cpu_to_le16(param_offset);
Steve French50c2f752007-07-13 00:33:32 +00002504 parm_data = (struct cifs_posix_lock *)
Steve French08547b02006-02-28 22:39:25 +00002505 (((char *) &pSMB->hdr.Protocol) + offset);
2506
2507 parm_data->lock_type = cpu_to_le16(lock_type);
Steve French790fe572007-07-07 19:25:05 +00002508 if (waitFlag) {
Steve French133672e2007-11-13 22:41:37 +00002509 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Steve Frenchcec6815a2006-05-30 18:07:17 +00002510 parm_data->lock_flags = cpu_to_le16(1);
Steve French3a5ff612006-07-14 22:37:11 +00002511 pSMB->Timeout = cpu_to_le32(-1);
2512 } else
2513 pSMB->Timeout = 0;
2514
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04002515 parm_data->pid = cpu_to_le32(netpid);
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002516 parm_data->start = cpu_to_le64(pLockData->fl_start);
Steve Frenchcec6815a2006-05-30 18:07:17 +00002517 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
Steve French08547b02006-02-28 22:39:25 +00002518
2519 pSMB->DataOffset = cpu_to_le16(offset);
Steve Frenchf26282c2006-03-01 09:17:37 +00002520 pSMB->Fid = smb_file_id;
Steve French08547b02006-02-28 22:39:25 +00002521 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2522 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002523 inc_rfc1001_len(pSMB, byte_count);
Steve French08547b02006-02-28 22:39:25 +00002524 pSMB->ByteCount = cpu_to_le16(byte_count);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002525 if (waitFlag) {
2526 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2527 (struct smb_hdr *) pSMBr, &bytes_returned);
2528 } else {
Steve French133672e2007-11-13 22:41:37 +00002529 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002530 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French133672e2007-11-13 22:41:37 +00002531 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2532 &resp_buf_type, timeout);
2533 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2534 not try to free it twice below on exit */
2535 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002536 }
2537
Steve French08547b02006-02-28 22:39:25 +00002538 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002539 cFYI(1, "Send error in Posix Lock = %d", rc);
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002540 } else if (get_flag) {
2541 /* lock structure can be returned on get */
2542 __u16 data_offset;
2543 __u16 data_count;
2544 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French08547b02006-02-28 22:39:25 +00002545
Jeff Layton820a8032011-05-04 08:05:26 -04002546 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002547 rc = -EIO; /* bad smb */
2548 goto plk_err_exit;
2549 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002550 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2551 data_count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French790fe572007-07-07 19:25:05 +00002552 if (data_count < sizeof(struct cifs_posix_lock)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002553 rc = -EIO;
2554 goto plk_err_exit;
2555 }
2556 parm_data = (struct cifs_posix_lock *)
2557 ((char *)&pSMBr->hdr.Protocol + data_offset);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002558 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002559 pLockData->fl_type = F_UNLCK;
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002560 else {
2561 if (parm_data->lock_type ==
2562 __constant_cpu_to_le16(CIFS_RDLCK))
2563 pLockData->fl_type = F_RDLCK;
2564 else if (parm_data->lock_type ==
2565 __constant_cpu_to_le16(CIFS_WRLCK))
2566 pLockData->fl_type = F_WRLCK;
2567
Steve French5443d132011-03-13 05:08:25 +00002568 pLockData->fl_start = le64_to_cpu(parm_data->start);
2569 pLockData->fl_end = pLockData->fl_start +
2570 le64_to_cpu(parm_data->length) - 1;
2571 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002572 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002573 }
Steve French50c2f752007-07-13 00:33:32 +00002574
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002575plk_err_exit:
Steve French08547b02006-02-28 22:39:25 +00002576 if (pSMB)
2577 cifs_small_buf_release(pSMB);
2578
Steve French133672e2007-11-13 22:41:37 +00002579 if (resp_buf_type == CIFS_SMALL_BUFFER)
2580 cifs_small_buf_release(iov[0].iov_base);
2581 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2582 cifs_buf_release(iov[0].iov_base);
2583
Steve French08547b02006-02-28 22:39:25 +00002584 /* Note: On -EAGAIN error only caller can retry on handle based calls
2585 since file handle passed in no longer valid */
2586
2587 return rc;
2588}
2589
2590
2591int
Steve French96daf2b2011-05-27 04:34:02 +00002592CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593{
2594 int rc = 0;
2595 CLOSE_REQ *pSMB = NULL;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002596 cFYI(1, "In CIFSSMBClose");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597
2598/* do not retry on dead session on close */
2599 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
Steve French790fe572007-07-07 19:25:05 +00002600 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 return 0;
2602 if (rc)
2603 return rc;
2604
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 pSMB->FileID = (__u16) smb_file_id;
Steve Frenchb815f1e2006-10-02 05:53:29 +00002606 pSMB->LastWriteTime = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04002608 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002609 cifs_stats_inc(&tcon->num_closes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 if (rc) {
Steve French790fe572007-07-07 19:25:05 +00002611 if (rc != -EINTR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612 /* EINTR is expected when user ctl-c to kill app */
Joe Perchesb6b38f72010-04-21 03:50:45 +00002613 cERROR(1, "Send error in Close = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002614 }
2615 }
2616
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 /* Since session is dead, file will be closed on server already */
Steve French790fe572007-07-07 19:25:05 +00002618 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 rc = 0;
2620
2621 return rc;
2622}
2623
2624int
Steve French96daf2b2011-05-27 04:34:02 +00002625CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
Steve Frenchb298f222009-02-21 21:17:43 +00002626{
2627 int rc = 0;
2628 FLUSH_REQ *pSMB = NULL;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002629 cFYI(1, "In CIFSSMBFlush");
Steve Frenchb298f222009-02-21 21:17:43 +00002630
2631 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2632 if (rc)
2633 return rc;
2634
2635 pSMB->FileID = (__u16) smb_file_id;
2636 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04002637 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frenchb298f222009-02-21 21:17:43 +00002638 cifs_stats_inc(&tcon->num_flushes);
2639 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002640 cERROR(1, "Send error in Flush = %d", rc);
Steve Frenchb298f222009-02-21 21:17:43 +00002641
2642 return rc;
2643}
2644
2645int
Steve French96daf2b2011-05-27 04:34:02 +00002646CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002648 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649{
2650 int rc = 0;
2651 RENAME_REQ *pSMB = NULL;
2652 RENAME_RSP *pSMBr = NULL;
2653 int bytes_returned;
2654 int name_len, name_len2;
2655 __u16 count;
2656
Joe Perchesb6b38f72010-04-21 03:50:45 +00002657 cFYI(1, "In CIFSSMBRename");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658renameRetry:
2659 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2660 (void **) &pSMBr);
2661 if (rc)
2662 return rc;
2663
2664 pSMB->BufferFormat = 0x04;
2665 pSMB->SearchAttributes =
2666 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2667 ATTR_DIRECTORY);
2668
2669 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2670 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06002671 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
2672 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 name_len++; /* trailing null */
2674 name_len *= 2;
2675 pSMB->OldFileName[name_len] = 0x04; /* pad */
2676 /* protocol requires ASCII signature byte on Unicode string */
2677 pSMB->OldFileName[name_len + 1] = 0x00;
2678 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06002679 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2680 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2682 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002683 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 name_len = strnlen(fromName, PATH_MAX);
2685 name_len++; /* trailing null */
2686 strncpy(pSMB->OldFileName, fromName, name_len);
2687 name_len2 = strnlen(toName, PATH_MAX);
2688 name_len2++; /* trailing null */
2689 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2690 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2691 name_len2++; /* trailing null */
2692 name_len2++; /* signature byte */
2693 }
2694
2695 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002696 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 pSMB->ByteCount = cpu_to_le16(count);
2698
2699 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2700 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002701 cifs_stats_inc(&tcon->num_renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002702 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002703 cFYI(1, "Send error in rename = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002704
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 cifs_buf_release(pSMB);
2706
2707 if (rc == -EAGAIN)
2708 goto renameRetry;
2709
2710 return rc;
2711}
2712
Steve French96daf2b2011-05-27 04:34:02 +00002713int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
Jeff Layton391e5752008-09-24 11:32:59 -04002714 int netfid, const char *target_name,
Steve French50c2f752007-07-13 00:33:32 +00002715 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716{
2717 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2718 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French50c2f752007-07-13 00:33:32 +00002719 struct set_file_rename *rename_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 char *data_offset;
2721 char dummy_string[30];
2722 int rc = 0;
2723 int bytes_returned = 0;
2724 int len_of_str;
2725 __u16 params, param_offset, offset, count, byte_count;
2726
Joe Perchesb6b38f72010-04-21 03:50:45 +00002727 cFYI(1, "Rename to File by handle");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2729 (void **) &pSMBr);
2730 if (rc)
2731 return rc;
2732
2733 params = 6;
2734 pSMB->MaxSetupCount = 0;
2735 pSMB->Reserved = 0;
2736 pSMB->Flags = 0;
2737 pSMB->Timeout = 0;
2738 pSMB->Reserved2 = 0;
2739 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2740 offset = param_offset + params;
2741
2742 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2743 rename_info = (struct set_file_rename *) data_offset;
2744 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002745 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 pSMB->SetupCount = 1;
2747 pSMB->Reserved3 = 0;
2748 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2749 byte_count = 3 /* pad */ + params;
2750 pSMB->ParameterCount = cpu_to_le16(params);
2751 pSMB->TotalParameterCount = pSMB->ParameterCount;
2752 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2753 pSMB->DataOffset = cpu_to_le16(offset);
2754 /* construct random name ".cifs_tmp<inodenum><mid>" */
2755 rename_info->overwrite = cpu_to_le32(1);
2756 rename_info->root_fid = 0;
2757 /* unicode only call */
Steve French790fe572007-07-07 19:25:05 +00002758 if (target_name == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002759 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
Steve Frenchacbbb762012-01-18 22:32:33 -06002760 len_of_str =
2761 cifsConvertToUTF16((__le16 *)rename_info->target_name,
Steve French737b7582005-04-28 22:41:06 -07002762 dummy_string, 24, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002763 } else {
Steve Frenchacbbb762012-01-18 22:32:33 -06002764 len_of_str =
2765 cifsConvertToUTF16((__le16 *)rename_info->target_name,
Steve French50c2f752007-07-13 00:33:32 +00002766 target_name, PATH_MAX, nls_codepage,
2767 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768 }
2769 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
Jeff Layton391e5752008-09-24 11:32:59 -04002770 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 byte_count += count;
2772 pSMB->DataCount = cpu_to_le16(count);
2773 pSMB->TotalDataCount = pSMB->DataCount;
2774 pSMB->Fid = netfid;
2775 pSMB->InformationLevel =
2776 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2777 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002778 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 pSMB->ByteCount = cpu_to_le16(byte_count);
2780 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00002781 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002782 cifs_stats_inc(&pTcon->num_t2renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002783 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002784 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
Steve Frencha5a2b482005-08-20 21:42:53 -07002785
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 cifs_buf_release(pSMB);
2787
2788 /* Note: On -EAGAIN error only caller can retry on handle based calls
2789 since file handle passed in no longer valid */
2790
2791 return rc;
2792}
2793
2794int
Steve French96daf2b2011-05-27 04:34:02 +00002795CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
Steve French50c2f752007-07-13 00:33:32 +00002796 const __u16 target_tid, const char *toName, const int flags,
2797 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798{
2799 int rc = 0;
2800 COPY_REQ *pSMB = NULL;
2801 COPY_RSP *pSMBr = NULL;
2802 int bytes_returned;
2803 int name_len, name_len2;
2804 __u16 count;
2805
Joe Perchesb6b38f72010-04-21 03:50:45 +00002806 cFYI(1, "In CIFSSMBCopy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807copyRetry:
2808 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2809 (void **) &pSMBr);
2810 if (rc)
2811 return rc;
2812
2813 pSMB->BufferFormat = 0x04;
2814 pSMB->Tid2 = target_tid;
2815
2816 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2817
2818 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -06002819 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2820 fromName, PATH_MAX, nls_codepage,
2821 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 name_len++; /* trailing null */
2823 name_len *= 2;
2824 pSMB->OldFileName[name_len] = 0x04; /* pad */
2825 /* protocol requires ASCII signature byte on Unicode string */
2826 pSMB->OldFileName[name_len + 1] = 0x00;
Steve French50c2f752007-07-13 00:33:32 +00002827 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06002828 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2829 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2831 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002832 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 name_len = strnlen(fromName, PATH_MAX);
2834 name_len++; /* trailing null */
2835 strncpy(pSMB->OldFileName, fromName, name_len);
2836 name_len2 = strnlen(toName, PATH_MAX);
2837 name_len2++; /* trailing null */
2838 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2839 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2840 name_len2++; /* trailing null */
2841 name_len2++; /* signature byte */
2842 }
2843
2844 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002845 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846 pSMB->ByteCount = cpu_to_le16(count);
2847
2848 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2849 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2850 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002851 cFYI(1, "Send error in copy = %d with %d files copied",
2852 rc, le16_to_cpu(pSMBr->CopyCount));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 }
Steve French0d817bc2008-05-22 02:02:03 +00002854 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855
2856 if (rc == -EAGAIN)
2857 goto copyRetry;
2858
2859 return rc;
2860}
2861
2862int
Steve French96daf2b2011-05-27 04:34:02 +00002863CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 const char *fromName, const char *toName,
2865 const struct nls_table *nls_codepage)
2866{
2867 TRANSACTION2_SPI_REQ *pSMB = NULL;
2868 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2869 char *data_offset;
2870 int name_len;
2871 int name_len_target;
2872 int rc = 0;
2873 int bytes_returned = 0;
2874 __u16 params, param_offset, offset, byte_count;
2875
Joe Perchesb6b38f72010-04-21 03:50:45 +00002876 cFYI(1, "In Symlink Unix style");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877createSymLinkRetry:
2878 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2879 (void **) &pSMBr);
2880 if (rc)
2881 return rc;
2882
2883 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2884 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06002885 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2886 /* find define for this maxpathcomponent */
2887 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 name_len++; /* trailing null */
2889 name_len *= 2;
2890
Steve French50c2f752007-07-13 00:33:32 +00002891 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 name_len = strnlen(fromName, PATH_MAX);
2893 name_len++; /* trailing null */
2894 strncpy(pSMB->FileName, fromName, name_len);
2895 }
2896 params = 6 + name_len;
2897 pSMB->MaxSetupCount = 0;
2898 pSMB->Reserved = 0;
2899 pSMB->Flags = 0;
2900 pSMB->Timeout = 0;
2901 pSMB->Reserved2 = 0;
2902 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002903 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 offset = param_offset + params;
2905
2906 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2907 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2908 name_len_target =
Steve Frenchacbbb762012-01-18 22:32:33 -06002909 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2910 /* find define for this maxpathcomponent */
2911 , nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 name_len_target++; /* trailing null */
2913 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00002914 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 name_len_target = strnlen(toName, PATH_MAX);
2916 name_len_target++; /* trailing null */
2917 strncpy(data_offset, toName, name_len_target);
2918 }
2919
2920 pSMB->MaxParameterCount = cpu_to_le16(2);
2921 /* BB find exact max on data count below from sess */
2922 pSMB->MaxDataCount = cpu_to_le16(1000);
2923 pSMB->SetupCount = 1;
2924 pSMB->Reserved3 = 0;
2925 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2926 byte_count = 3 /* pad */ + params + name_len_target;
2927 pSMB->DataCount = cpu_to_le16(name_len_target);
2928 pSMB->ParameterCount = cpu_to_le16(params);
2929 pSMB->TotalDataCount = pSMB->DataCount;
2930 pSMB->TotalParameterCount = pSMB->ParameterCount;
2931 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2932 pSMB->DataOffset = cpu_to_le16(offset);
2933 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2934 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002935 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936 pSMB->ByteCount = cpu_to_le16(byte_count);
2937 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2938 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07002939 cifs_stats_inc(&tcon->num_symlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002940 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002941 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942
Steve French0d817bc2008-05-22 02:02:03 +00002943 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944
2945 if (rc == -EAGAIN)
2946 goto createSymLinkRetry;
2947
2948 return rc;
2949}
2950
2951int
Steve French96daf2b2011-05-27 04:34:02 +00002952CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002953 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002954 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955{
2956 TRANSACTION2_SPI_REQ *pSMB = NULL;
2957 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2958 char *data_offset;
2959 int name_len;
2960 int name_len_target;
2961 int rc = 0;
2962 int bytes_returned = 0;
2963 __u16 params, param_offset, offset, byte_count;
2964
Joe Perchesb6b38f72010-04-21 03:50:45 +00002965 cFYI(1, "In Create Hard link Unix style");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966createHardLinkRetry:
2967 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2968 (void **) &pSMBr);
2969 if (rc)
2970 return rc;
2971
2972 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -06002973 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2974 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 name_len++; /* trailing null */
2976 name_len *= 2;
2977
Steve French50c2f752007-07-13 00:33:32 +00002978 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 name_len = strnlen(toName, PATH_MAX);
2980 name_len++; /* trailing null */
2981 strncpy(pSMB->FileName, toName, name_len);
2982 }
2983 params = 6 + name_len;
2984 pSMB->MaxSetupCount = 0;
2985 pSMB->Reserved = 0;
2986 pSMB->Flags = 0;
2987 pSMB->Timeout = 0;
2988 pSMB->Reserved2 = 0;
2989 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002990 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002991 offset = param_offset + params;
2992
2993 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2994 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2995 name_len_target =
Steve Frenchacbbb762012-01-18 22:32:33 -06002996 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2997 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 name_len_target++; /* trailing null */
2999 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003000 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 name_len_target = strnlen(fromName, PATH_MAX);
3002 name_len_target++; /* trailing null */
3003 strncpy(data_offset, fromName, name_len_target);
3004 }
3005
3006 pSMB->MaxParameterCount = cpu_to_le16(2);
3007 /* BB find exact max on data count below from sess*/
3008 pSMB->MaxDataCount = cpu_to_le16(1000);
3009 pSMB->SetupCount = 1;
3010 pSMB->Reserved3 = 0;
3011 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3012 byte_count = 3 /* pad */ + params + name_len_target;
3013 pSMB->ParameterCount = cpu_to_le16(params);
3014 pSMB->TotalParameterCount = pSMB->ParameterCount;
3015 pSMB->DataCount = cpu_to_le16(name_len_target);
3016 pSMB->TotalDataCount = pSMB->DataCount;
3017 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3018 pSMB->DataOffset = cpu_to_le16(offset);
3019 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
3020 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003021 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003022 pSMB->ByteCount = cpu_to_le16(byte_count);
3023 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3024 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07003025 cifs_stats_inc(&tcon->num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00003026 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003027 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028
3029 cifs_buf_release(pSMB);
3030 if (rc == -EAGAIN)
3031 goto createHardLinkRetry;
3032
3033 return rc;
3034}
3035
3036int
Steve French96daf2b2011-05-27 04:34:02 +00003037CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07003039 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040{
3041 int rc = 0;
3042 NT_RENAME_REQ *pSMB = NULL;
3043 RENAME_RSP *pSMBr = NULL;
3044 int bytes_returned;
3045 int name_len, name_len2;
3046 __u16 count;
3047
Joe Perchesb6b38f72010-04-21 03:50:45 +00003048 cFYI(1, "In CIFSCreateHardLink");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049winCreateHardLinkRetry:
3050
3051 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
3052 (void **) &pSMBr);
3053 if (rc)
3054 return rc;
3055
3056 pSMB->SearchAttributes =
3057 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3058 ATTR_DIRECTORY);
3059 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
3060 pSMB->ClusterCount = 0;
3061
3062 pSMB->BufferFormat = 0x04;
3063
3064 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3065 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003066 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
3067 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068 name_len++; /* trailing null */
3069 name_len *= 2;
Jeff Laytonfcc7c092009-02-28 12:59:03 -05003070
3071 /* protocol specifies ASCII buffer format (0x04) for unicode */
3072 pSMB->OldFileName[name_len] = 0x04;
3073 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06003075 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3076 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003077 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3078 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00003079 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 name_len = strnlen(fromName, PATH_MAX);
3081 name_len++; /* trailing null */
3082 strncpy(pSMB->OldFileName, fromName, name_len);
3083 name_len2 = strnlen(toName, PATH_MAX);
3084 name_len2++; /* trailing null */
3085 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3086 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
3087 name_len2++; /* trailing null */
3088 name_len2++; /* signature byte */
3089 }
3090
3091 count = 1 /* string type byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003092 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 pSMB->ByteCount = cpu_to_le16(count);
3094
3095 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3096 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07003097 cifs_stats_inc(&tcon->num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00003098 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003099 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00003100
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101 cifs_buf_release(pSMB);
3102 if (rc == -EAGAIN)
3103 goto winCreateHardLinkRetry;
3104
3105 return rc;
3106}
3107
3108int
Steve French96daf2b2011-05-27 04:34:02 +00003109CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
Jeff Layton460b9692009-04-30 07:17:56 -04003110 const unsigned char *searchName, char **symlinkinfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003111 const struct nls_table *nls_codepage)
3112{
3113/* SMB_QUERY_FILE_UNIX_LINK */
3114 TRANSACTION2_QPI_REQ *pSMB = NULL;
3115 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3116 int rc = 0;
3117 int bytes_returned;
3118 int name_len;
3119 __u16 params, byte_count;
Jeff Layton460b9692009-04-30 07:17:56 -04003120 char *data_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121
Joe Perchesb6b38f72010-04-21 03:50:45 +00003122 cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123
3124querySymLinkRetry:
3125 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3126 (void **) &pSMBr);
3127 if (rc)
3128 return rc;
3129
3130 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3131 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003132 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3133 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003134 name_len++; /* trailing null */
3135 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003136 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 name_len = strnlen(searchName, PATH_MAX);
3138 name_len++; /* trailing null */
3139 strncpy(pSMB->FileName, searchName, name_len);
3140 }
3141
3142 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3143 pSMB->TotalDataCount = 0;
3144 pSMB->MaxParameterCount = cpu_to_le16(2);
Jeff Layton46a75742009-05-24 18:45:17 -04003145 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146 pSMB->MaxSetupCount = 0;
3147 pSMB->Reserved = 0;
3148 pSMB->Flags = 0;
3149 pSMB->Timeout = 0;
3150 pSMB->Reserved2 = 0;
3151 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00003152 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 pSMB->DataCount = 0;
3154 pSMB->DataOffset = 0;
3155 pSMB->SetupCount = 1;
3156 pSMB->Reserved3 = 0;
3157 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3158 byte_count = params + 1 /* pad */ ;
3159 pSMB->TotalParameterCount = cpu_to_le16(params);
3160 pSMB->ParameterCount = pSMB->TotalParameterCount;
3161 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3162 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003163 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 pSMB->ByteCount = cpu_to_le16(byte_count);
3165
3166 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3167 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3168 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003169 cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170 } else {
3171 /* decode response */
3172
3173 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003175 if (rc || get_bcc(&pSMBr->hdr) < 2)
Jeff Layton460b9692009-04-30 07:17:56 -04003176 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177 else {
Steve French0e0d2cf2009-05-01 05:27:32 +00003178 bool is_unicode;
Jeff Layton460b9692009-04-30 07:17:56 -04003179 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180
Jeff Layton460b9692009-04-30 07:17:56 -04003181 data_start = ((char *) &pSMBr->hdr.Protocol) +
3182 le16_to_cpu(pSMBr->t2.DataOffset);
3183
Steve French0e0d2cf2009-05-01 05:27:32 +00003184 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3185 is_unicode = true;
3186 else
3187 is_unicode = false;
3188
Steve French737b7582005-04-28 22:41:06 -07003189 /* BB FIXME investigate remapping reserved chars here */
Steve Frenchacbbb762012-01-18 22:32:33 -06003190 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3191 count, is_unicode, nls_codepage);
Jeff Layton8b6427a2009-05-19 09:57:03 -04003192 if (!*symlinkinfo)
Jeff Layton460b9692009-04-30 07:17:56 -04003193 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194 }
3195 }
3196 cifs_buf_release(pSMB);
3197 if (rc == -EAGAIN)
3198 goto querySymLinkRetry;
3199 return rc;
3200}
3201
Steve Frenchc52a9552011-02-24 06:16:22 +00003202#ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
3203/*
3204 * Recent Windows versions now create symlinks more frequently
3205 * and they use the "reparse point" mechanism below. We can of course
3206 * do symlinks nicely to Samba and other servers which support the
3207 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3208 * "MF" symlinks optionally, but for recent Windows we really need to
3209 * reenable the code below and fix the cifs_symlink callers to handle this.
3210 * In the interim this code has been moved to its own config option so
3211 * it is not compiled in by default until callers fixed up and more tested.
3212 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213int
Steve French96daf2b2011-05-27 04:34:02 +00003214CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 const unsigned char *searchName,
Steve French50c2f752007-07-13 00:33:32 +00003216 char *symlinkinfo, const int buflen, __u16 fid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 const struct nls_table *nls_codepage)
3218{
3219 int rc = 0;
3220 int bytes_returned;
Steve French50c2f752007-07-13 00:33:32 +00003221 struct smb_com_transaction_ioctl_req *pSMB;
3222 struct smb_com_transaction_ioctl_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223
Joe Perchesb6b38f72010-04-21 03:50:45 +00003224 cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3226 (void **) &pSMBr);
3227 if (rc)
3228 return rc;
3229
3230 pSMB->TotalParameterCount = 0 ;
3231 pSMB->TotalDataCount = 0;
3232 pSMB->MaxParameterCount = cpu_to_le32(2);
3233 /* BB find exact data count max from sess structure BB */
Jeff Laytonc974bef2011-10-11 06:41:32 -04003234 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 pSMB->MaxSetupCount = 4;
3236 pSMB->Reserved = 0;
3237 pSMB->ParameterOffset = 0;
3238 pSMB->DataCount = 0;
3239 pSMB->DataOffset = 0;
3240 pSMB->SetupCount = 4;
3241 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3242 pSMB->ParameterCount = pSMB->TotalParameterCount;
3243 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3244 pSMB->IsFsctl = 1; /* FSCTL */
3245 pSMB->IsRootFlag = 0;
3246 pSMB->Fid = fid; /* file handle always le */
3247 pSMB->ByteCount = 0;
3248
3249 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3250 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3251 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003252 cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003253 } else { /* decode response */
3254 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
3255 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
Jeff Layton820a8032011-05-04 08:05:26 -04003256 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3257 /* BB also check enough total bytes returned */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003258 rc = -EIO; /* bad smb */
Steve Frenchafe48c32009-05-02 05:25:46 +00003259 goto qreparse_out;
3260 }
3261 if (data_count && (data_count < 2048)) {
3262 char *end_of_smb = 2 /* sizeof byte count */ +
Jeff Layton820a8032011-05-04 08:05:26 -04003263 get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264
Steve Frenchafe48c32009-05-02 05:25:46 +00003265 struct reparse_data *reparse_buf =
Steve French50c2f752007-07-13 00:33:32 +00003266 (struct reparse_data *)
3267 ((char *)&pSMBr->hdr.Protocol
3268 + data_offset);
Steve Frenchafe48c32009-05-02 05:25:46 +00003269 if ((char *)reparse_buf >= end_of_smb) {
3270 rc = -EIO;
3271 goto qreparse_out;
3272 }
3273 if ((reparse_buf->LinkNamesBuf +
3274 reparse_buf->TargetNameOffset +
3275 reparse_buf->TargetNameLen) > end_of_smb) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003276 cFYI(1, "reparse buf beyond SMB");
Steve Frenchafe48c32009-05-02 05:25:46 +00003277 rc = -EIO;
3278 goto qreparse_out;
3279 }
Steve French50c2f752007-07-13 00:33:32 +00003280
Steve Frenchafe48c32009-05-02 05:25:46 +00003281 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3282 cifs_from_ucs2(symlinkinfo, (__le16 *)
Steve French50c2f752007-07-13 00:33:32 +00003283 (reparse_buf->LinkNamesBuf +
3284 reparse_buf->TargetNameOffset),
Steve Frenchafe48c32009-05-02 05:25:46 +00003285 buflen,
3286 reparse_buf->TargetNameLen,
3287 nls_codepage, 0);
3288 } else { /* ASCII names */
3289 strncpy(symlinkinfo,
3290 reparse_buf->LinkNamesBuf +
3291 reparse_buf->TargetNameOffset,
3292 min_t(const int, buflen,
3293 reparse_buf->TargetNameLen));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003294 }
Steve Frenchafe48c32009-05-02 05:25:46 +00003295 } else {
3296 rc = -EIO;
Joe Perchesb6b38f72010-04-21 03:50:45 +00003297 cFYI(1, "Invalid return data count on "
3298 "get reparse info ioctl");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299 }
Steve Frenchafe48c32009-05-02 05:25:46 +00003300 symlinkinfo[buflen] = 0; /* just in case so the caller
3301 does not go off the end of the buffer */
Joe Perchesb6b38f72010-04-21 03:50:45 +00003302 cFYI(1, "readlink result - %s", symlinkinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 }
Steve French989c7e52009-05-02 05:32:20 +00003304
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305qreparse_out:
Steve French4a6d87f2005-08-13 08:15:54 -07003306 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307
3308 /* Note: On -EAGAIN error only caller can retry on handle based calls
3309 since file handle passed in no longer valid */
3310
3311 return rc;
3312}
Steve Frenchc52a9552011-02-24 06:16:22 +00003313#endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314
3315#ifdef CONFIG_CIFS_POSIX
3316
3317/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
Steve French50c2f752007-07-13 00:33:32 +00003318static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3319 struct cifs_posix_ace *cifs_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320{
3321 /* u8 cifs fields do not need le conversion */
Steve Frenchff7feac2005-11-15 16:45:16 -08003322 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3323 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3324 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
Joe Perchesb6b38f72010-04-21 03:50:45 +00003325 /* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003326
3327 return;
3328}
3329
3330/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
Steve French50c2f752007-07-13 00:33:32 +00003331static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3332 const int acl_type, const int size_of_data_area)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333{
3334 int size = 0;
3335 int i;
3336 __u16 count;
Steve French50c2f752007-07-13 00:33:32 +00003337 struct cifs_posix_ace *pACE;
3338 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3339 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340
3341 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3342 return -EOPNOTSUPP;
3343
Steve French790fe572007-07-07 19:25:05 +00003344 if (acl_type & ACL_TYPE_ACCESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003345 count = le16_to_cpu(cifs_acl->access_entry_count);
3346 pACE = &cifs_acl->ace_array[0];
3347 size = sizeof(struct cifs_posix_acl);
3348 size += sizeof(struct cifs_posix_ace) * count;
3349 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003350 if (size_of_data_area < size) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003351 cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
3352 size_of_data_area, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353 return -EINVAL;
3354 }
Steve French790fe572007-07-07 19:25:05 +00003355 } else if (acl_type & ACL_TYPE_DEFAULT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 count = le16_to_cpu(cifs_acl->access_entry_count);
3357 size = sizeof(struct cifs_posix_acl);
3358 size += sizeof(struct cifs_posix_ace) * count;
3359/* skip past access ACEs to get to default ACEs */
3360 pACE = &cifs_acl->ace_array[count];
3361 count = le16_to_cpu(cifs_acl->default_entry_count);
3362 size += sizeof(struct cifs_posix_ace) * count;
3363 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003364 if (size_of_data_area < size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365 return -EINVAL;
3366 } else {
3367 /* illegal type */
3368 return -EINVAL;
3369 }
3370
3371 size = posix_acl_xattr_size(count);
Steve French790fe572007-07-07 19:25:05 +00003372 if ((buflen == 0) || (local_acl == NULL)) {
Steve French50c2f752007-07-13 00:33:32 +00003373 /* used to query ACL EA size */
Steve French790fe572007-07-07 19:25:05 +00003374 } else if (size > buflen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375 return -ERANGE;
3376 } else /* buffer big enough */ {
Steve Frenchff7feac2005-11-15 16:45:16 -08003377 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
Steve French50c2f752007-07-13 00:33:32 +00003378 for (i = 0; i < count ; i++) {
3379 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3380 pACE++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003381 }
3382 }
3383 return size;
3384}
3385
Steve French50c2f752007-07-13 00:33:32 +00003386static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3387 const posix_acl_xattr_entry *local_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388{
3389 __u16 rc = 0; /* 0 = ACL converted ok */
3390
Steve Frenchff7feac2005-11-15 16:45:16 -08003391 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3392 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 /* BB is there a better way to handle the large uid? */
Steve French790fe572007-07-07 19:25:05 +00003394 if (local_ace->e_id == cpu_to_le32(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 /* Probably no need to le convert -1 on any arch but can not hurt */
3396 cifs_ace->cifs_uid = cpu_to_le64(-1);
Steve French50c2f752007-07-13 00:33:32 +00003397 } else
Steve Frenchff7feac2005-11-15 16:45:16 -08003398 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
Joe Perchesb6b38f72010-04-21 03:50:45 +00003399 /*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 return rc;
3401}
3402
3403/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
Steve French50c2f752007-07-13 00:33:32 +00003404static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3405 const int buflen, const int acl_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406{
3407 __u16 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00003408 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3409 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410 int count;
3411 int i;
3412
Steve French790fe572007-07-07 19:25:05 +00003413 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003414 return 0;
3415
3416 count = posix_acl_xattr_count((size_t)buflen);
Joe Perchesb6b38f72010-04-21 03:50:45 +00003417 cFYI(1, "setting acl with %d entries from buf of length %d and "
Steve French63135e02007-07-17 17:34:02 +00003418 "version of %d",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003419 count, buflen, le32_to_cpu(local_acl->a_version));
Steve French790fe572007-07-07 19:25:05 +00003420 if (le32_to_cpu(local_acl->a_version) != 2) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003421 cFYI(1, "unknown POSIX ACL version %d",
3422 le32_to_cpu(local_acl->a_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 return 0;
3424 }
3425 cifs_acl->version = cpu_to_le16(1);
Steve French790fe572007-07-07 19:25:05 +00003426 if (acl_type == ACL_TYPE_ACCESS)
Steve Frenchff7feac2005-11-15 16:45:16 -08003427 cifs_acl->access_entry_count = cpu_to_le16(count);
Steve French790fe572007-07-07 19:25:05 +00003428 else if (acl_type == ACL_TYPE_DEFAULT)
Steve Frenchff7feac2005-11-15 16:45:16 -08003429 cifs_acl->default_entry_count = cpu_to_le16(count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003431 cFYI(1, "unknown ACL type %d", acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432 return 0;
3433 }
Steve French50c2f752007-07-13 00:33:32 +00003434 for (i = 0; i < count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3436 &local_acl->a_entries[i]);
Steve French790fe572007-07-07 19:25:05 +00003437 if (rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 /* ACE not converted */
3439 break;
3440 }
3441 }
Steve French790fe572007-07-07 19:25:05 +00003442 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3444 rc += sizeof(struct cifs_posix_acl);
3445 /* BB add check to make sure ACL does not overflow SMB */
3446 }
3447 return rc;
3448}
3449
3450int
Steve French96daf2b2011-05-27 04:34:02 +00003451CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003452 const unsigned char *searchName,
3453 char *acl_inf, const int buflen, const int acl_type,
3454 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455{
3456/* SMB_QUERY_POSIX_ACL */
3457 TRANSACTION2_QPI_REQ *pSMB = NULL;
3458 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3459 int rc = 0;
3460 int bytes_returned;
3461 int name_len;
3462 __u16 params, byte_count;
Steve French50c2f752007-07-13 00:33:32 +00003463
Joe Perchesb6b38f72010-04-21 03:50:45 +00003464 cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465
3466queryAclRetry:
3467 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3468 (void **) &pSMBr);
3469 if (rc)
3470 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003471
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3473 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003474 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3475 searchName, PATH_MAX, nls_codepage,
3476 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 name_len++; /* trailing null */
3478 name_len *= 2;
3479 pSMB->FileName[name_len] = 0;
3480 pSMB->FileName[name_len+1] = 0;
Steve French50c2f752007-07-13 00:33:32 +00003481 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482 name_len = strnlen(searchName, PATH_MAX);
3483 name_len++; /* trailing null */
3484 strncpy(pSMB->FileName, searchName, name_len);
3485 }
3486
3487 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3488 pSMB->TotalDataCount = 0;
3489 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French50c2f752007-07-13 00:33:32 +00003490 /* BB find exact max data count below from sess structure BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 pSMB->MaxDataCount = cpu_to_le16(4000);
3492 pSMB->MaxSetupCount = 0;
3493 pSMB->Reserved = 0;
3494 pSMB->Flags = 0;
3495 pSMB->Timeout = 0;
3496 pSMB->Reserved2 = 0;
3497 pSMB->ParameterOffset = cpu_to_le16(
Steve French50c2f752007-07-13 00:33:32 +00003498 offsetof(struct smb_com_transaction2_qpi_req,
3499 InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500 pSMB->DataCount = 0;
3501 pSMB->DataOffset = 0;
3502 pSMB->SetupCount = 1;
3503 pSMB->Reserved3 = 0;
3504 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3505 byte_count = params + 1 /* pad */ ;
3506 pSMB->TotalParameterCount = cpu_to_le16(params);
3507 pSMB->ParameterCount = pSMB->TotalParameterCount;
3508 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3509 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003510 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003511 pSMB->ByteCount = cpu_to_le16(byte_count);
3512
3513 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3514 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French0a4b92c2006-01-12 15:44:21 -08003515 cifs_stats_inc(&tcon->num_acl_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003517 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003518 } else {
3519 /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00003520
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003523 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 rc = -EIO; /* bad smb */
3525 else {
3526 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3527 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3528 rc = cifs_copy_posix_acl(acl_inf,
3529 (char *)&pSMBr->hdr.Protocol+data_offset,
Steve French50c2f752007-07-13 00:33:32 +00003530 buflen, acl_type, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531 }
3532 }
3533 cifs_buf_release(pSMB);
3534 if (rc == -EAGAIN)
3535 goto queryAclRetry;
3536 return rc;
3537}
3538
3539int
Steve French96daf2b2011-05-27 04:34:02 +00003540CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003541 const unsigned char *fileName,
3542 const char *local_acl, const int buflen,
3543 const int acl_type,
3544 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545{
3546 struct smb_com_transaction2_spi_req *pSMB = NULL;
3547 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3548 char *parm_data;
3549 int name_len;
3550 int rc = 0;
3551 int bytes_returned = 0;
3552 __u16 params, byte_count, data_count, param_offset, offset;
3553
Joe Perchesb6b38f72010-04-21 03:50:45 +00003554 cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555setAclRetry:
3556 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003557 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558 if (rc)
3559 return rc;
3560 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3561 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003562 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3563 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 name_len++; /* trailing null */
3565 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003566 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567 name_len = strnlen(fileName, PATH_MAX);
3568 name_len++; /* trailing null */
3569 strncpy(pSMB->FileName, fileName, name_len);
3570 }
3571 params = 6 + name_len;
3572 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00003573 /* BB find max SMB size from sess */
3574 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003575 pSMB->MaxSetupCount = 0;
3576 pSMB->Reserved = 0;
3577 pSMB->Flags = 0;
3578 pSMB->Timeout = 0;
3579 pSMB->Reserved2 = 0;
3580 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00003581 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 offset = param_offset + params;
3583 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3584 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3585
3586 /* convert to on the wire format for POSIX ACL */
Steve French50c2f752007-07-13 00:33:32 +00003587 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588
Steve French790fe572007-07-07 19:25:05 +00003589 if (data_count == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590 rc = -EOPNOTSUPP;
3591 goto setACLerrorExit;
3592 }
3593 pSMB->DataOffset = cpu_to_le16(offset);
3594 pSMB->SetupCount = 1;
3595 pSMB->Reserved3 = 0;
3596 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3597 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3598 byte_count = 3 /* pad */ + params + data_count;
3599 pSMB->DataCount = cpu_to_le16(data_count);
3600 pSMB->TotalDataCount = pSMB->DataCount;
3601 pSMB->ParameterCount = cpu_to_le16(params);
3602 pSMB->TotalParameterCount = pSMB->ParameterCount;
3603 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003604 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 pSMB->ByteCount = cpu_to_le16(byte_count);
3606 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003607 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00003608 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003609 cFYI(1, "Set POSIX ACL returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610
3611setACLerrorExit:
3612 cifs_buf_release(pSMB);
3613 if (rc == -EAGAIN)
3614 goto setAclRetry;
3615 return rc;
3616}
3617
Steve Frenchf654bac2005-04-28 22:41:04 -07003618/* BB fix tabs in this function FIXME BB */
3619int
Steve French96daf2b2011-05-27 04:34:02 +00003620CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +00003621 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
Steve Frenchf654bac2005-04-28 22:41:04 -07003622{
Steve French50c2f752007-07-13 00:33:32 +00003623 int rc = 0;
3624 struct smb_t2_qfi_req *pSMB = NULL;
3625 struct smb_t2_qfi_rsp *pSMBr = NULL;
3626 int bytes_returned;
3627 __u16 params, byte_count;
Steve Frenchf654bac2005-04-28 22:41:04 -07003628
Joe Perchesb6b38f72010-04-21 03:50:45 +00003629 cFYI(1, "In GetExtAttr");
Steve French790fe572007-07-07 19:25:05 +00003630 if (tcon == NULL)
3631 return -ENODEV;
Steve Frenchf654bac2005-04-28 22:41:04 -07003632
3633GetExtAttrRetry:
Steve French790fe572007-07-07 19:25:05 +00003634 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3635 (void **) &pSMBr);
3636 if (rc)
3637 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003638
Steve Frenchad7a2922008-02-07 23:25:02 +00003639 params = 2 /* level */ + 2 /* fid */;
Steve French790fe572007-07-07 19:25:05 +00003640 pSMB->t2.TotalDataCount = 0;
3641 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3642 /* BB find exact max data count below from sess structure BB */
3643 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3644 pSMB->t2.MaxSetupCount = 0;
3645 pSMB->t2.Reserved = 0;
3646 pSMB->t2.Flags = 0;
3647 pSMB->t2.Timeout = 0;
3648 pSMB->t2.Reserved2 = 0;
3649 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3650 Fid) - 4);
3651 pSMB->t2.DataCount = 0;
3652 pSMB->t2.DataOffset = 0;
3653 pSMB->t2.SetupCount = 1;
3654 pSMB->t2.Reserved3 = 0;
3655 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3656 byte_count = params + 1 /* pad */ ;
3657 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3658 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3659 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3660 pSMB->Pad = 0;
Steve Frenchf654bac2005-04-28 22:41:04 -07003661 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003662 inc_rfc1001_len(pSMB, byte_count);
Steve French790fe572007-07-07 19:25:05 +00003663 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
Steve Frenchf654bac2005-04-28 22:41:04 -07003664
Steve French790fe572007-07-07 19:25:05 +00003665 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3666 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3667 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003668 cFYI(1, "error %d in GetExtAttr", rc);
Steve French790fe572007-07-07 19:25:05 +00003669 } else {
3670 /* decode response */
3671 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00003672 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003673 if (rc || get_bcc(&pSMBr->hdr) < 2)
Steve French790fe572007-07-07 19:25:05 +00003674 /* If rc should we check for EOPNOSUPP and
3675 disable the srvino flag? or in caller? */
3676 rc = -EIO; /* bad smb */
3677 else {
3678 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3679 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3680 struct file_chattr_info *pfinfo;
3681 /* BB Do we need a cast or hash here ? */
3682 if (count != 16) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003683 cFYI(1, "Illegal size ret in GetExtAttr");
Steve French790fe572007-07-07 19:25:05 +00003684 rc = -EIO;
3685 goto GetExtAttrOut;
3686 }
3687 pfinfo = (struct file_chattr_info *)
3688 (data_offset + (char *) &pSMBr->hdr.Protocol);
3689 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
Steve Frenchf654bac2005-04-28 22:41:04 -07003690 *pMask = le64_to_cpu(pfinfo->mask);
Steve French790fe572007-07-07 19:25:05 +00003691 }
3692 }
Steve Frenchf654bac2005-04-28 22:41:04 -07003693GetExtAttrOut:
Steve French790fe572007-07-07 19:25:05 +00003694 cifs_buf_release(pSMB);
3695 if (rc == -EAGAIN)
3696 goto GetExtAttrRetry;
3697 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003698}
3699
Steve Frenchf654bac2005-04-28 22:41:04 -07003700#endif /* CONFIG_POSIX */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701
Jeff Layton79df1ba2010-12-06 12:52:08 -05003702#ifdef CONFIG_CIFS_ACL
3703/*
3704 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3705 * all NT TRANSACTS that we init here have total parm and data under about 400
3706 * bytes (to fit in small cifs buffer size), which is the case so far, it
3707 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3708 * returned setup area) and MaxParameterCount (returned parms size) must be set
3709 * by caller
3710 */
3711static int
3712smb_init_nttransact(const __u16 sub_command, const int setup_count,
Steve French96daf2b2011-05-27 04:34:02 +00003713 const int parm_len, struct cifs_tcon *tcon,
Jeff Layton79df1ba2010-12-06 12:52:08 -05003714 void **ret_buf)
3715{
3716 int rc;
3717 __u32 temp_offset;
3718 struct smb_com_ntransact_req *pSMB;
3719
3720 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3721 (void **)&pSMB);
3722 if (rc)
3723 return rc;
3724 *ret_buf = (void *)pSMB;
3725 pSMB->Reserved = 0;
3726 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3727 pSMB->TotalDataCount = 0;
Jeff Laytonc974bef2011-10-11 06:41:32 -04003728 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Jeff Layton79df1ba2010-12-06 12:52:08 -05003729 pSMB->ParameterCount = pSMB->TotalParameterCount;
3730 pSMB->DataCount = pSMB->TotalDataCount;
3731 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3732 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3733 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3734 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3735 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3736 pSMB->SubCommand = cpu_to_le16(sub_command);
3737 return 0;
3738}
3739
3740static int
3741validate_ntransact(char *buf, char **ppparm, char **ppdata,
3742 __u32 *pparmlen, __u32 *pdatalen)
3743{
3744 char *end_of_smb;
3745 __u32 data_count, data_offset, parm_count, parm_offset;
3746 struct smb_com_ntransact_rsp *pSMBr;
Jeff Layton820a8032011-05-04 08:05:26 -04003747 u16 bcc;
Jeff Layton79df1ba2010-12-06 12:52:08 -05003748
3749 *pdatalen = 0;
3750 *pparmlen = 0;
3751
3752 if (buf == NULL)
3753 return -EINVAL;
3754
3755 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3756
Jeff Layton820a8032011-05-04 08:05:26 -04003757 bcc = get_bcc(&pSMBr->hdr);
3758 end_of_smb = 2 /* sizeof byte count */ + bcc +
Jeff Layton79df1ba2010-12-06 12:52:08 -05003759 (char *)&pSMBr->ByteCount;
3760
3761 data_offset = le32_to_cpu(pSMBr->DataOffset);
3762 data_count = le32_to_cpu(pSMBr->DataCount);
3763 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3764 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3765
3766 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3767 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3768
3769 /* should we also check that parm and data areas do not overlap? */
3770 if (*ppparm > end_of_smb) {
3771 cFYI(1, "parms start after end of smb");
3772 return -EINVAL;
3773 } else if (parm_count + *ppparm > end_of_smb) {
3774 cFYI(1, "parm end after end of smb");
3775 return -EINVAL;
3776 } else if (*ppdata > end_of_smb) {
3777 cFYI(1, "data starts after end of smb");
3778 return -EINVAL;
3779 } else if (data_count + *ppdata > end_of_smb) {
3780 cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
3781 *ppdata, data_count, (data_count + *ppdata),
3782 end_of_smb, pSMBr);
3783 return -EINVAL;
Jeff Layton820a8032011-05-04 08:05:26 -04003784 } else if (parm_count + data_count > bcc) {
Jeff Layton79df1ba2010-12-06 12:52:08 -05003785 cFYI(1, "parm count and data count larger than SMB");
3786 return -EINVAL;
3787 }
3788 *pdatalen = data_count;
3789 *pparmlen = parm_count;
3790 return 0;
3791}
3792
Steve French0a4b92c2006-01-12 15:44:21 -08003793/* Get Security Descriptor (by handle) from remote server for a file or dir */
3794int
Steve French96daf2b2011-05-27 04:34:02 +00003795CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
Steve French630f3f02007-10-25 21:17:17 +00003796 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
Steve French0a4b92c2006-01-12 15:44:21 -08003797{
3798 int rc = 0;
3799 int buf_type = 0;
Steve Frenchad7a2922008-02-07 23:25:02 +00003800 QUERY_SEC_DESC_REQ *pSMB;
Steve French0a4b92c2006-01-12 15:44:21 -08003801 struct kvec iov[1];
3802
Joe Perchesb6b38f72010-04-21 03:50:45 +00003803 cFYI(1, "GetCifsACL");
Steve French0a4b92c2006-01-12 15:44:21 -08003804
Steve French630f3f02007-10-25 21:17:17 +00003805 *pbuflen = 0;
3806 *acl_inf = NULL;
3807
Steve Frenchb9c7a2b2007-10-26 23:40:20 +00003808 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
Steve French0a4b92c2006-01-12 15:44:21 -08003809 8 /* parm len */, tcon, (void **) &pSMB);
3810 if (rc)
3811 return rc;
3812
3813 pSMB->MaxParameterCount = cpu_to_le32(4);
3814 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3815 pSMB->MaxSetupCount = 0;
3816 pSMB->Fid = fid; /* file handle always le */
3817 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3818 CIFS_ACL_DACL);
3819 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003820 inc_rfc1001_len(pSMB, 11);
Steve French0a4b92c2006-01-12 15:44:21 -08003821 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003822 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French0a4b92c2006-01-12 15:44:21 -08003823
Steve Frencha761ac52007-10-18 21:45:27 +00003824 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
Jeff Layton77499812011-01-11 07:24:23 -05003825 0);
Steve French0a4b92c2006-01-12 15:44:21 -08003826 cifs_stats_inc(&tcon->num_acl_get);
3827 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003828 cFYI(1, "Send error in QuerySecDesc = %d", rc);
Steve French0a4b92c2006-01-12 15:44:21 -08003829 } else { /* decode response */
Steve Frenchad7a2922008-02-07 23:25:02 +00003830 __le32 *parm;
Steve French630f3f02007-10-25 21:17:17 +00003831 __u32 parm_len;
3832 __u32 acl_len;
Steve French50c2f752007-07-13 00:33:32 +00003833 struct smb_com_ntransact_rsp *pSMBr;
Steve French630f3f02007-10-25 21:17:17 +00003834 char *pdata;
Steve French0a4b92c2006-01-12 15:44:21 -08003835
3836/* validate_nttransact */
Steve French50c2f752007-07-13 00:33:32 +00003837 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
Steve French630f3f02007-10-25 21:17:17 +00003838 &pdata, &parm_len, pbuflen);
Steve French790fe572007-07-07 19:25:05 +00003839 if (rc)
Steve French0a4b92c2006-01-12 15:44:21 -08003840 goto qsec_out;
3841 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3842
Joe Perchesb6b38f72010-04-21 03:50:45 +00003843 cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
Steve French0a4b92c2006-01-12 15:44:21 -08003844
3845 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3846 rc = -EIO; /* bad smb */
Steve French630f3f02007-10-25 21:17:17 +00003847 *pbuflen = 0;
Steve French0a4b92c2006-01-12 15:44:21 -08003848 goto qsec_out;
3849 }
3850
3851/* BB check that data area is minimum length and as big as acl_len */
3852
Steve Frenchaf6f4612007-10-16 18:40:37 +00003853 acl_len = le32_to_cpu(*parm);
Steve French630f3f02007-10-25 21:17:17 +00003854 if (acl_len != *pbuflen) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003855 cERROR(1, "acl length %d does not match %d",
3856 acl_len, *pbuflen);
Steve French630f3f02007-10-25 21:17:17 +00003857 if (*pbuflen > acl_len)
3858 *pbuflen = acl_len;
3859 }
Steve French0a4b92c2006-01-12 15:44:21 -08003860
Steve French630f3f02007-10-25 21:17:17 +00003861 /* check if buffer is big enough for the acl
3862 header followed by the smallest SID */
3863 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3864 (*pbuflen >= 64 * 1024)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003865 cERROR(1, "bad acl length %d", *pbuflen);
Steve French630f3f02007-10-25 21:17:17 +00003866 rc = -EINVAL;
3867 *pbuflen = 0;
3868 } else {
3869 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3870 if (*acl_inf == NULL) {
3871 *pbuflen = 0;
3872 rc = -ENOMEM;
3873 }
3874 memcpy(*acl_inf, pdata, *pbuflen);
3875 }
Steve French0a4b92c2006-01-12 15:44:21 -08003876 }
3877qsec_out:
Steve French790fe572007-07-07 19:25:05 +00003878 if (buf_type == CIFS_SMALL_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003879 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00003880 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003881 cifs_buf_release(iov[0].iov_base);
Steve French4b8f9302006-02-26 16:41:18 +00003882/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French0a4b92c2006-01-12 15:44:21 -08003883 return rc;
3884}
Steve French97837582007-12-31 07:47:21 +00003885
3886int
Steve French96daf2b2011-05-27 04:34:02 +00003887CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003888 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
Steve French97837582007-12-31 07:47:21 +00003889{
3890 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3891 int rc = 0;
3892 int bytes_returned = 0;
3893 SET_SEC_DESC_REQ *pSMB = NULL;
3894 NTRANSACT_RSP *pSMBr = NULL;
3895
3896setCifsAclRetry:
3897 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3898 (void **) &pSMBr);
3899 if (rc)
3900 return (rc);
3901
3902 pSMB->MaxSetupCount = 0;
3903 pSMB->Reserved = 0;
3904
3905 param_count = 8;
3906 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3907 data_count = acllen;
3908 data_offset = param_offset + param_count;
3909 byte_count = 3 /* pad */ + param_count;
3910
3911 pSMB->DataCount = cpu_to_le32(data_count);
3912 pSMB->TotalDataCount = pSMB->DataCount;
3913 pSMB->MaxParameterCount = cpu_to_le32(4);
3914 pSMB->MaxDataCount = cpu_to_le32(16384);
3915 pSMB->ParameterCount = cpu_to_le32(param_count);
3916 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3917 pSMB->TotalParameterCount = pSMB->ParameterCount;
3918 pSMB->DataOffset = cpu_to_le32(data_offset);
3919 pSMB->SetupCount = 0;
3920 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3921 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3922
3923 pSMB->Fid = fid; /* file handle always le */
3924 pSMB->Reserved2 = 0;
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003925 pSMB->AclFlags = cpu_to_le32(aclflag);
Steve French97837582007-12-31 07:47:21 +00003926
3927 if (pntsd && acllen) {
3928 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3929 (char *) pntsd,
3930 acllen);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003931 inc_rfc1001_len(pSMB, byte_count + data_count);
Steve French97837582007-12-31 07:47:21 +00003932 } else
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003933 inc_rfc1001_len(pSMB, byte_count);
Steve French97837582007-12-31 07:47:21 +00003934
3935 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3936 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3937
Joe Perchesb6b38f72010-04-21 03:50:45 +00003938 cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
Steve French97837582007-12-31 07:47:21 +00003939 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00003940 cFYI(1, "Set CIFS ACL returned %d", rc);
Steve French97837582007-12-31 07:47:21 +00003941 cifs_buf_release(pSMB);
3942
3943 if (rc == -EAGAIN)
3944 goto setCifsAclRetry;
3945
3946 return (rc);
3947}
3948
Jeff Layton79df1ba2010-12-06 12:52:08 -05003949#endif /* CONFIG_CIFS_ACL */
Steve French0a4b92c2006-01-12 15:44:21 -08003950
Steve French6b8edfe2005-08-23 20:26:03 -07003951/* Legacy Query Path Information call for lookup to old servers such
3952 as Win9x/WinME */
Steve French96daf2b2011-05-27 04:34:02 +00003953int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003954 const unsigned char *searchName,
3955 FILE_ALL_INFO *pFinfo,
3956 const struct nls_table *nls_codepage, int remap)
Steve French6b8edfe2005-08-23 20:26:03 -07003957{
Steve Frenchad7a2922008-02-07 23:25:02 +00003958 QUERY_INFORMATION_REQ *pSMB;
3959 QUERY_INFORMATION_RSP *pSMBr;
Steve French6b8edfe2005-08-23 20:26:03 -07003960 int rc = 0;
3961 int bytes_returned;
3962 int name_len;
3963
Joe Perchesb6b38f72010-04-21 03:50:45 +00003964 cFYI(1, "In SMBQPath path %s", searchName);
Steve French6b8edfe2005-08-23 20:26:03 -07003965QInfRetry:
3966 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003967 (void **) &pSMBr);
Steve French6b8edfe2005-08-23 20:26:03 -07003968 if (rc)
3969 return rc;
3970
3971 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3972 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003973 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3974 searchName, PATH_MAX, nls_codepage,
3975 remap);
Steve French6b8edfe2005-08-23 20:26:03 -07003976 name_len++; /* trailing null */
3977 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003978 } else {
Steve French6b8edfe2005-08-23 20:26:03 -07003979 name_len = strnlen(searchName, PATH_MAX);
3980 name_len++; /* trailing null */
3981 strncpy(pSMB->FileName, searchName, name_len);
3982 }
3983 pSMB->BufferFormat = 0x04;
Steve French50c2f752007-07-13 00:33:32 +00003984 name_len++; /* account for buffer type byte */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003985 inc_rfc1001_len(pSMB, (__u16)name_len);
Steve French6b8edfe2005-08-23 20:26:03 -07003986 pSMB->ByteCount = cpu_to_le16(name_len);
3987
3988 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003989 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French6b8edfe2005-08-23 20:26:03 -07003990 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00003991 cFYI(1, "Send error in QueryInfo = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00003992 } else if (pFinfo) {
Steve French1bd5bbc2006-09-28 03:35:57 +00003993 struct timespec ts;
3994 __u32 time = le32_to_cpu(pSMBr->last_write_time);
Steve Frenchad7a2922008-02-07 23:25:02 +00003995
3996 /* decode response */
Steve French1bd5bbc2006-09-28 03:35:57 +00003997 /* BB FIXME - add time zone adjustment BB */
Steve French6b8edfe2005-08-23 20:26:03 -07003998 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
Steve French1bd5bbc2006-09-28 03:35:57 +00003999 ts.tv_nsec = 0;
4000 ts.tv_sec = time;
4001 /* decode time fields */
Al Viro733f99a2006-10-14 16:48:26 +01004002 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
Steve French1bd5bbc2006-09-28 03:35:57 +00004003 pFinfo->LastWriteTime = pFinfo->ChangeTime;
4004 pFinfo->LastAccessTime = 0;
Steve French70ca7342005-09-22 16:32:06 -07004005 pFinfo->AllocationSize =
4006 cpu_to_le64(le32_to_cpu(pSMBr->size));
4007 pFinfo->EndOfFile = pFinfo->AllocationSize;
4008 pFinfo->Attributes =
4009 cpu_to_le32(le16_to_cpu(pSMBr->attr));
Steve French6b8edfe2005-08-23 20:26:03 -07004010 } else
4011 rc = -EIO; /* bad buffer passed in */
4012
4013 cifs_buf_release(pSMB);
4014
4015 if (rc == -EAGAIN)
4016 goto QInfRetry;
4017
4018 return rc;
4019}
4020
Jeff Laytonbcd53572010-02-12 07:44:16 -05004021int
Steve French96daf2b2011-05-27 04:34:02 +00004022CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Laytonbcd53572010-02-12 07:44:16 -05004023 u16 netfid, FILE_ALL_INFO *pFindData)
4024{
4025 struct smb_t2_qfi_req *pSMB = NULL;
4026 struct smb_t2_qfi_rsp *pSMBr = NULL;
4027 int rc = 0;
4028 int bytes_returned;
4029 __u16 params, byte_count;
Steve French6b8edfe2005-08-23 20:26:03 -07004030
Jeff Laytonbcd53572010-02-12 07:44:16 -05004031QFileInfoRetry:
4032 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4033 (void **) &pSMBr);
4034 if (rc)
4035 return rc;
Steve French6b8edfe2005-08-23 20:26:03 -07004036
Jeff Laytonbcd53572010-02-12 07:44:16 -05004037 params = 2 /* level */ + 2 /* fid */;
4038 pSMB->t2.TotalDataCount = 0;
4039 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4040 /* BB find exact max data count below from sess structure BB */
4041 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4042 pSMB->t2.MaxSetupCount = 0;
4043 pSMB->t2.Reserved = 0;
4044 pSMB->t2.Flags = 0;
4045 pSMB->t2.Timeout = 0;
4046 pSMB->t2.Reserved2 = 0;
4047 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4048 Fid) - 4);
4049 pSMB->t2.DataCount = 0;
4050 pSMB->t2.DataOffset = 0;
4051 pSMB->t2.SetupCount = 1;
4052 pSMB->t2.Reserved3 = 0;
4053 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4054 byte_count = params + 1 /* pad */ ;
4055 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4056 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4057 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4058 pSMB->Pad = 0;
4059 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004060 inc_rfc1001_len(pSMB, byte_count);
Jeff Laytonbcd53572010-02-12 07:44:16 -05004061
4062 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4063 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4064 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004065 cFYI(1, "Send error in QPathInfo = %d", rc);
Jeff Laytonbcd53572010-02-12 07:44:16 -05004066 } else { /* decode response */
4067 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4068
4069 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4070 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004071 else if (get_bcc(&pSMBr->hdr) < 40)
Jeff Laytonbcd53572010-02-12 07:44:16 -05004072 rc = -EIO; /* bad smb */
4073 else if (pFindData) {
4074 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4075 memcpy((char *) pFindData,
4076 (char *) &pSMBr->hdr.Protocol +
4077 data_offset, sizeof(FILE_ALL_INFO));
4078 } else
4079 rc = -ENOMEM;
4080 }
4081 cifs_buf_release(pSMB);
4082 if (rc == -EAGAIN)
4083 goto QFileInfoRetry;
4084
4085 return rc;
4086}
Steve French6b8edfe2005-08-23 20:26:03 -07004087
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088int
Steve French96daf2b2011-05-27 04:34:02 +00004089CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004090 const unsigned char *searchName,
Steve Frenchad7a2922008-02-07 23:25:02 +00004091 FILE_ALL_INFO *pFindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004092 int legacy /* old style infolevel */,
Steve French737b7582005-04-28 22:41:06 -07004093 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094{
4095/* level 263 SMB_QUERY_FILE_ALL_INFO */
4096 TRANSACTION2_QPI_REQ *pSMB = NULL;
4097 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4098 int rc = 0;
4099 int bytes_returned;
4100 int name_len;
4101 __u16 params, byte_count;
4102
Joe Perchesb6b38f72010-04-21 03:50:45 +00004103/* cFYI(1, "In QPathInfo path %s", searchName); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004104QPathInfoRetry:
4105 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4106 (void **) &pSMBr);
4107 if (rc)
4108 return rc;
4109
4110 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4111 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004112 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4113 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004114 name_len++; /* trailing null */
4115 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004116 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117 name_len = strnlen(searchName, PATH_MAX);
4118 name_len++; /* trailing null */
4119 strncpy(pSMB->FileName, searchName, name_len);
4120 }
4121
Steve French50c2f752007-07-13 00:33:32 +00004122 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004123 pSMB->TotalDataCount = 0;
4124 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00004125 /* BB find exact max SMB PDU from sess structure BB */
4126 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004127 pSMB->MaxSetupCount = 0;
4128 pSMB->Reserved = 0;
4129 pSMB->Flags = 0;
4130 pSMB->Timeout = 0;
4131 pSMB->Reserved2 = 0;
4132 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004133 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134 pSMB->DataCount = 0;
4135 pSMB->DataOffset = 0;
4136 pSMB->SetupCount = 1;
4137 pSMB->Reserved3 = 0;
4138 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4139 byte_count = params + 1 /* pad */ ;
4140 pSMB->TotalParameterCount = cpu_to_le16(params);
4141 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve French790fe572007-07-07 19:25:05 +00004142 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004143 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4144 else
4145 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004146 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004147 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004148 pSMB->ByteCount = cpu_to_le16(byte_count);
4149
4150 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4151 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4152 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004153 cFYI(1, "Send error in QPathInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004154 } else { /* decode response */
4155 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4156
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004157 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4158 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004159 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004160 rc = -EIO; /* bad smb */
Jeff Layton820a8032011-05-04 08:05:26 -04004161 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
Steve French50c2f752007-07-13 00:33:32 +00004162 rc = -EIO; /* 24 or 26 expected but we do not read
4163 last field */
4164 else if (pFindData) {
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004165 int size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004166 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Steve Frenchad7a2922008-02-07 23:25:02 +00004167
4168 /* On legacy responses we do not read the last field,
4169 EAsize, fortunately since it varies by subdialect and
4170 also note it differs on Set vs. Get, ie two bytes or 4
4171 bytes depending but we don't care here */
4172 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004173 size = sizeof(FILE_INFO_STANDARD);
4174 else
4175 size = sizeof(FILE_ALL_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004176 memcpy((char *) pFindData,
4177 (char *) &pSMBr->hdr.Protocol +
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004178 data_offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004179 } else
4180 rc = -ENOMEM;
4181 }
4182 cifs_buf_release(pSMB);
4183 if (rc == -EAGAIN)
4184 goto QPathInfoRetry;
4185
4186 return rc;
4187}
4188
4189int
Steve French96daf2b2011-05-27 04:34:02 +00004190CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004191 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4192{
4193 struct smb_t2_qfi_req *pSMB = NULL;
4194 struct smb_t2_qfi_rsp *pSMBr = NULL;
4195 int rc = 0;
4196 int bytes_returned;
4197 __u16 params, byte_count;
4198
4199UnixQFileInfoRetry:
4200 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4201 (void **) &pSMBr);
4202 if (rc)
4203 return rc;
4204
4205 params = 2 /* level */ + 2 /* fid */;
4206 pSMB->t2.TotalDataCount = 0;
4207 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4208 /* BB find exact max data count below from sess structure BB */
4209 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4210 pSMB->t2.MaxSetupCount = 0;
4211 pSMB->t2.Reserved = 0;
4212 pSMB->t2.Flags = 0;
4213 pSMB->t2.Timeout = 0;
4214 pSMB->t2.Reserved2 = 0;
4215 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4216 Fid) - 4);
4217 pSMB->t2.DataCount = 0;
4218 pSMB->t2.DataOffset = 0;
4219 pSMB->t2.SetupCount = 1;
4220 pSMB->t2.Reserved3 = 0;
4221 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4222 byte_count = params + 1 /* pad */ ;
4223 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4224 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4225 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4226 pSMB->Pad = 0;
4227 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004228 inc_rfc1001_len(pSMB, byte_count);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004229
4230 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4231 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4232 if (rc) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004233 cFYI(1, "Send error in QPathInfo = %d", rc);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004234 } else { /* decode response */
4235 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4236
Jeff Layton820a8032011-05-04 08:05:26 -04004237 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Steve Frenchf19159d2010-04-21 04:12:10 +00004238 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004239 "Unix Extensions can be disabled on mount "
Steve Frenchf19159d2010-04-21 04:12:10 +00004240 "by specifying the nosfu mount option.");
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004241 rc = -EIO; /* bad smb */
4242 } else {
4243 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4244 memcpy((char *) pFindData,
4245 (char *) &pSMBr->hdr.Protocol +
4246 data_offset,
4247 sizeof(FILE_UNIX_BASIC_INFO));
4248 }
4249 }
4250
4251 cifs_buf_release(pSMB);
4252 if (rc == -EAGAIN)
4253 goto UnixQFileInfoRetry;
4254
4255 return rc;
4256}
4257
4258int
Steve French96daf2b2011-05-27 04:34:02 +00004259CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004260 const unsigned char *searchName,
Steve French582d21e2008-05-13 04:54:12 +00004261 FILE_UNIX_BASIC_INFO *pFindData,
Steve French737b7582005-04-28 22:41:06 -07004262 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004263{
4264/* SMB_QUERY_FILE_UNIX_BASIC */
4265 TRANSACTION2_QPI_REQ *pSMB = NULL;
4266 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4267 int rc = 0;
4268 int bytes_returned = 0;
4269 int name_len;
4270 __u16 params, byte_count;
4271
Joe Perchesb6b38f72010-04-21 03:50:45 +00004272 cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004273UnixQPathInfoRetry:
4274 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4275 (void **) &pSMBr);
4276 if (rc)
4277 return rc;
4278
4279 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4280 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004281 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4282 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004283 name_len++; /* trailing null */
4284 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004285 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004286 name_len = strnlen(searchName, PATH_MAX);
4287 name_len++; /* trailing null */
4288 strncpy(pSMB->FileName, searchName, name_len);
4289 }
4290
Steve French50c2f752007-07-13 00:33:32 +00004291 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004292 pSMB->TotalDataCount = 0;
4293 pSMB->MaxParameterCount = cpu_to_le16(2);
4294 /* BB find exact max SMB PDU from sess structure BB */
Steve French50c2f752007-07-13 00:33:32 +00004295 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296 pSMB->MaxSetupCount = 0;
4297 pSMB->Reserved = 0;
4298 pSMB->Flags = 0;
4299 pSMB->Timeout = 0;
4300 pSMB->Reserved2 = 0;
4301 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004302 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303 pSMB->DataCount = 0;
4304 pSMB->DataOffset = 0;
4305 pSMB->SetupCount = 1;
4306 pSMB->Reserved3 = 0;
4307 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4308 byte_count = params + 1 /* pad */ ;
4309 pSMB->TotalParameterCount = cpu_to_le16(params);
4310 pSMB->ParameterCount = pSMB->TotalParameterCount;
4311 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4312 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004313 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004314 pSMB->ByteCount = cpu_to_le16(byte_count);
4315
4316 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4317 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4318 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004319 cFYI(1, "Send error in QPathInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004320 } else { /* decode response */
4321 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4322
Jeff Layton820a8032011-05-04 08:05:26 -04004323 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004324 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
Steve French1e71f252007-09-20 15:30:07 +00004325 "Unix Extensions can be disabled on mount "
Joe Perchesb6b38f72010-04-21 03:50:45 +00004326 "by specifying the nosfu mount option.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004327 rc = -EIO; /* bad smb */
4328 } else {
4329 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4330 memcpy((char *) pFindData,
4331 (char *) &pSMBr->hdr.Protocol +
4332 data_offset,
Steve French630f3f02007-10-25 21:17:17 +00004333 sizeof(FILE_UNIX_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004334 }
4335 }
4336 cifs_buf_release(pSMB);
4337 if (rc == -EAGAIN)
4338 goto UnixQPathInfoRetry;
4339
4340 return rc;
4341}
4342
Linus Torvalds1da177e2005-04-16 15:20:36 -07004343/* xid, tcon, searchName and codepage are input parms, rest are returned */
4344int
Steve French96daf2b2011-05-27 04:34:02 +00004345CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004346 const char *searchName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347 const struct nls_table *nls_codepage,
Steve French50c2f752007-07-13 00:33:32 +00004348 __u16 *pnetfid,
4349 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350{
4351/* level 257 SMB_ */
4352 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4353 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004354 T2_FFIRST_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004355 int rc = 0;
4356 int bytes_returned = 0;
4357 int name_len;
4358 __u16 params, byte_count;
4359
Joe Perchesb6b38f72010-04-21 03:50:45 +00004360 cFYI(1, "In FindFirst for %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004361
4362findFirstRetry:
4363 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4364 (void **) &pSMBr);
4365 if (rc)
4366 return rc;
4367
4368 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4369 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004370 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4371 PATH_MAX, nls_codepage, remap);
Steve French737b7582005-04-28 22:41:06 -07004372 /* We can not add the asterik earlier in case
4373 it got remapped to 0xF03A as if it were part of the
4374 directory name instead of a wildcard */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004375 name_len *= 2;
Jeremy Allisonac670552005-06-22 17:26:35 -07004376 pSMB->FileName[name_len] = dirsep;
Steve French737b7582005-04-28 22:41:06 -07004377 pSMB->FileName[name_len+1] = 0;
4378 pSMB->FileName[name_len+2] = '*';
4379 pSMB->FileName[name_len+3] = 0;
4380 name_len += 4; /* now the trailing null */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004381 pSMB->FileName[name_len] = 0; /* null terminate just in case */
4382 pSMB->FileName[name_len+1] = 0;
Steve French737b7582005-04-28 22:41:06 -07004383 name_len += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004384 } else { /* BB add check for overrun of SMB buf BB */
4385 name_len = strnlen(searchName, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004386/* BB fix here and in unicode clause above ie
Steve French790fe572007-07-07 19:25:05 +00004387 if (name_len > buffersize-header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004388 free buffer exit; BB */
4389 strncpy(pSMB->FileName, searchName, name_len);
Jeremy Allisonac670552005-06-22 17:26:35 -07004390 pSMB->FileName[name_len] = dirsep;
Steve French68575472005-04-30 11:10:57 -07004391 pSMB->FileName[name_len+1] = '*';
4392 pSMB->FileName[name_len+2] = 0;
4393 name_len += 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004394 }
4395
4396 params = 12 + name_len /* includes null */ ;
4397 pSMB->TotalDataCount = 0; /* no EAs */
4398 pSMB->MaxParameterCount = cpu_to_le16(10);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004399 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004400 pSMB->MaxSetupCount = 0;
4401 pSMB->Reserved = 0;
4402 pSMB->Flags = 0;
4403 pSMB->Timeout = 0;
4404 pSMB->Reserved2 = 0;
4405 byte_count = params + 1 /* pad */ ;
4406 pSMB->TotalParameterCount = cpu_to_le16(params);
4407 pSMB->ParameterCount = pSMB->TotalParameterCount;
4408 pSMB->ParameterOffset = cpu_to_le16(
Steve French88274812006-03-09 22:21:45 +00004409 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4410 - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004411 pSMB->DataCount = 0;
4412 pSMB->DataOffset = 0;
4413 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4414 pSMB->Reserved3 = 0;
4415 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4416 pSMB->SearchAttributes =
4417 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4418 ATTR_DIRECTORY);
Steve French50c2f752007-07-13 00:33:32 +00004419 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4420 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
Linus Torvalds1da177e2005-04-16 15:20:36 -07004421 CIFS_SEARCH_RETURN_RESUME);
4422 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4423
4424 /* BB what should we set StorageType to? Does it matter? BB */
4425 pSMB->SearchStorageType = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004426 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 pSMB->ByteCount = cpu_to_le16(byte_count);
4428
4429 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4430 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07004431 cifs_stats_inc(&tcon->num_ffirst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004432
Steve French88274812006-03-09 22:21:45 +00004433 if (rc) {/* BB add logic to retry regular search if Unix search
4434 rejected unexpectedly by server */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004435 /* BB Add code to handle unsupported level rc */
Joe Perchesb6b38f72010-04-21 03:50:45 +00004436 cFYI(1, "Error in FindFirst = %d", rc);
Steve French1982c342005-08-17 12:38:22 -07004437
Steve French88274812006-03-09 22:21:45 +00004438 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004439
4440 /* BB eventually could optimize out free and realloc of buf */
4441 /* for this case */
4442 if (rc == -EAGAIN)
4443 goto findFirstRetry;
4444 } else { /* decode response */
4445 /* BB remember to free buffer if error BB */
4446 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00004447 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004448 unsigned int lnoff;
4449
Linus Torvalds1da177e2005-04-16 15:20:36 -07004450 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004451 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004452 else
Steve French4b18f2a2008-04-29 00:06:05 +00004453 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004454
4455 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004456 psrch_inf->smallBuf = 0;
Steve French50c2f752007-07-13 00:33:32 +00004457 psrch_inf->srch_entries_start =
4458 (char *) &pSMBr->hdr.Protocol +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004459 le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004460 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4461 le16_to_cpu(pSMBr->t2.ParameterOffset));
4462
Steve French790fe572007-07-07 19:25:05 +00004463 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004464 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004465 else
Steve French4b18f2a2008-04-29 00:06:05 +00004466 psrch_inf->endOfSearch = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467
Steve French50c2f752007-07-13 00:33:32 +00004468 psrch_inf->entries_in_buffer =
4469 le16_to_cpu(parms->SearchCount);
Steve French60808232006-04-22 15:53:05 +00004470 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004471 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004472 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004473 if (CIFSMaxBufSize < lnoff) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004474 cERROR(1, "ignoring corrupt resume name");
Steve Frenchb77d7532008-10-08 19:13:46 +00004475 psrch_inf->last_entry = NULL;
4476 return rc;
4477 }
4478
Steve French0752f152008-10-07 20:03:33 +00004479 psrch_inf->last_entry = psrch_inf->srch_entries_start +
Steve Frenchb77d7532008-10-08 19:13:46 +00004480 lnoff;
4481
Linus Torvalds1da177e2005-04-16 15:20:36 -07004482 *pnetfid = parms->SearchHandle;
4483 } else {
4484 cifs_buf_release(pSMB);
4485 }
4486 }
4487
4488 return rc;
4489}
4490
Steve French96daf2b2011-05-27 04:34:02 +00004491int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004492 __u16 searchHandle, struct cifs_search_info *psrch_inf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493{
4494 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4495 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004496 T2_FNEXT_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004497 char *response_data;
4498 int rc = 0;
Jeff Layton9438fab2011-08-23 07:21:28 -04004499 int bytes_returned;
4500 unsigned int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501 __u16 params, byte_count;
4502
Joe Perchesb6b38f72010-04-21 03:50:45 +00004503 cFYI(1, "In FindNext");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004504
Steve French4b18f2a2008-04-29 00:06:05 +00004505 if (psrch_inf->endOfSearch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004506 return -ENOENT;
4507
4508 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4509 (void **) &pSMBr);
4510 if (rc)
4511 return rc;
4512
Steve French50c2f752007-07-13 00:33:32 +00004513 params = 14; /* includes 2 bytes of null string, converted to LE below*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004514 byte_count = 0;
4515 pSMB->TotalDataCount = 0; /* no EAs */
4516 pSMB->MaxParameterCount = cpu_to_le16(8);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004517 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004518 pSMB->MaxSetupCount = 0;
4519 pSMB->Reserved = 0;
4520 pSMB->Flags = 0;
4521 pSMB->Timeout = 0;
4522 pSMB->Reserved2 = 0;
4523 pSMB->ParameterOffset = cpu_to_le16(
4524 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4525 pSMB->DataCount = 0;
4526 pSMB->DataOffset = 0;
4527 pSMB->SetupCount = 1;
4528 pSMB->Reserved3 = 0;
4529 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4530 pSMB->SearchHandle = searchHandle; /* always kept as le */
4531 pSMB->SearchCount =
Steve French630f3f02007-10-25 21:17:17 +00004532 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004533 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4534 pSMB->ResumeKey = psrch_inf->resume_key;
4535 pSMB->SearchFlags =
4536 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
4537
4538 name_len = psrch_inf->resume_name_len;
4539 params += name_len;
Steve French790fe572007-07-07 19:25:05 +00004540 if (name_len < PATH_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004541 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4542 byte_count += name_len;
Steve Frenchef6724e2005-08-02 21:31:05 -07004543 /* 14 byte parm len above enough for 2 byte null terminator */
4544 pSMB->ResumeFileName[name_len] = 0;
4545 pSMB->ResumeFileName[name_len+1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004546 } else {
4547 rc = -EINVAL;
4548 goto FNext2_err_exit;
4549 }
4550 byte_count = params + 1 /* pad */ ;
4551 pSMB->TotalParameterCount = cpu_to_le16(params);
4552 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004553 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004554 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00004555
Linus Torvalds1da177e2005-04-16 15:20:36 -07004556 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4557 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frencha4544342005-08-24 13:59:35 -07004558 cifs_stats_inc(&tcon->num_fnext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004559 if (rc) {
4560 if (rc == -EBADF) {
Steve French4b18f2a2008-04-29 00:06:05 +00004561 psrch_inf->endOfSearch = true;
Jeff Layton63534502008-05-12 19:56:05 -07004562 cifs_buf_release(pSMB);
Steve French50c2f752007-07-13 00:33:32 +00004563 rc = 0; /* search probably was closed at end of search*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004564 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00004565 cFYI(1, "FindNext returned = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004566 } else { /* decode response */
4567 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French50c2f752007-07-13 00:33:32 +00004568
Steve French790fe572007-07-07 19:25:05 +00004569 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004570 unsigned int lnoff;
4571
Linus Torvalds1da177e2005-04-16 15:20:36 -07004572 /* BB fixme add lock for file (srch_info) struct here */
4573 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004574 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004575 else
Steve French4b18f2a2008-04-29 00:06:05 +00004576 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577 response_data = (char *) &pSMBr->hdr.Protocol +
4578 le16_to_cpu(pSMBr->t2.ParameterOffset);
4579 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4580 response_data = (char *)&pSMBr->hdr.Protocol +
4581 le16_to_cpu(pSMBr->t2.DataOffset);
Steve French790fe572007-07-07 19:25:05 +00004582 if (psrch_inf->smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +00004583 cifs_small_buf_release(
4584 psrch_inf->ntwrk_buf_start);
4585 else
4586 cifs_buf_release(psrch_inf->ntwrk_buf_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004587 psrch_inf->srch_entries_start = response_data;
4588 psrch_inf->ntwrk_buf_start = (char *)pSMB;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004589 psrch_inf->smallBuf = 0;
Steve French790fe572007-07-07 19:25:05 +00004590 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004591 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004592 else
Steve French4b18f2a2008-04-29 00:06:05 +00004593 psrch_inf->endOfSearch = false;
Steve French50c2f752007-07-13 00:33:32 +00004594 psrch_inf->entries_in_buffer =
4595 le16_to_cpu(parms->SearchCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004596 psrch_inf->index_of_last_entry +=
4597 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004598 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004599 if (CIFSMaxBufSize < lnoff) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004600 cERROR(1, "ignoring corrupt resume name");
Steve Frenchb77d7532008-10-08 19:13:46 +00004601 psrch_inf->last_entry = NULL;
4602 return rc;
4603 } else
4604 psrch_inf->last_entry =
4605 psrch_inf->srch_entries_start + lnoff;
4606
Joe Perchesb6b38f72010-04-21 03:50:45 +00004607/* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
4608 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004609
4610 /* BB fixme add unlock here */
4611 }
4612
4613 }
4614
4615 /* BB On error, should we leave previous search buf (and count and
4616 last entry fields) intact or free the previous one? */
4617
4618 /* Note: On -EAGAIN error only caller can retry on handle based calls
4619 since file handle passed in no longer valid */
4620FNext2_err_exit:
4621 if (rc != 0)
4622 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004623 return rc;
4624}
4625
4626int
Steve French96daf2b2011-05-27 04:34:02 +00004627CIFSFindClose(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004628 const __u16 searchHandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004629{
4630 int rc = 0;
4631 FINDCLOSE_REQ *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004632
Joe Perchesb6b38f72010-04-21 03:50:45 +00004633 cFYI(1, "In CIFSSMBFindClose");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004634 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4635
4636 /* no sense returning error if session restarted
4637 as file handle has been closed */
Steve French790fe572007-07-07 19:25:05 +00004638 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004639 return 0;
4640 if (rc)
4641 return rc;
4642
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 pSMB->FileID = searchHandle;
4644 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04004645 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00004646 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00004647 cERROR(1, "Send error in FindClose = %d", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00004648
Steve Frencha4544342005-08-24 13:59:35 -07004649 cifs_stats_inc(&tcon->num_fclose);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004650
4651 /* Since session is dead, search handle closed on server already */
4652 if (rc == -EAGAIN)
4653 rc = 0;
4654
4655 return rc;
4656}
4657
Linus Torvalds1da177e2005-04-16 15:20:36 -07004658int
Steve French96daf2b2011-05-27 04:34:02 +00004659CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004660 const unsigned char *searchName,
Steve Frenchad7a2922008-02-07 23:25:02 +00004661 __u64 *inode_number,
Steve French50c2f752007-07-13 00:33:32 +00004662 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004663{
4664 int rc = 0;
4665 TRANSACTION2_QPI_REQ *pSMB = NULL;
4666 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4667 int name_len, bytes_returned;
4668 __u16 params, byte_count;
4669
Joe Perchesb6b38f72010-04-21 03:50:45 +00004670 cFYI(1, "In GetSrvInodeNum for %s", searchName);
Steve French790fe572007-07-07 19:25:05 +00004671 if (tcon == NULL)
Steve French50c2f752007-07-13 00:33:32 +00004672 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004673
4674GetInodeNumberRetry:
4675 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00004676 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004677 if (rc)
4678 return rc;
4679
Linus Torvalds1da177e2005-04-16 15:20:36 -07004680 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4681 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004682 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4683 searchName, PATH_MAX, nls_codepage,
4684 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004685 name_len++; /* trailing null */
4686 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004687 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004688 name_len = strnlen(searchName, PATH_MAX);
4689 name_len++; /* trailing null */
4690 strncpy(pSMB->FileName, searchName, name_len);
4691 }
4692
4693 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4694 pSMB->TotalDataCount = 0;
4695 pSMB->MaxParameterCount = cpu_to_le16(2);
4696 /* BB find exact max data count below from sess structure BB */
4697 pSMB->MaxDataCount = cpu_to_le16(4000);
4698 pSMB->MaxSetupCount = 0;
4699 pSMB->Reserved = 0;
4700 pSMB->Flags = 0;
4701 pSMB->Timeout = 0;
4702 pSMB->Reserved2 = 0;
4703 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004704 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004705 pSMB->DataCount = 0;
4706 pSMB->DataOffset = 0;
4707 pSMB->SetupCount = 1;
4708 pSMB->Reserved3 = 0;
4709 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4710 byte_count = params + 1 /* pad */ ;
4711 pSMB->TotalParameterCount = cpu_to_le16(params);
4712 pSMB->ParameterCount = pSMB->TotalParameterCount;
4713 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4714 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004715 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004716 pSMB->ByteCount = cpu_to_le16(byte_count);
4717
4718 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4719 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4720 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004721 cFYI(1, "error %d in QueryInternalInfo", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004722 } else {
4723 /* decode response */
4724 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004725 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04004726 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004727 /* If rc should we check for EOPNOSUPP and
4728 disable the srvino flag? or in caller? */
4729 rc = -EIO; /* bad smb */
Steve French50c2f752007-07-13 00:33:32 +00004730 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004731 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4732 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French50c2f752007-07-13 00:33:32 +00004733 struct file_internal_info *pfinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004734 /* BB Do we need a cast or hash here ? */
Steve French790fe572007-07-07 19:25:05 +00004735 if (count < 8) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004736 cFYI(1, "Illegal size ret in QryIntrnlInf");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004737 rc = -EIO;
4738 goto GetInodeNumOut;
4739 }
4740 pfinfo = (struct file_internal_info *)
4741 (data_offset + (char *) &pSMBr->hdr.Protocol);
Steve French85a6dac2009-04-01 05:22:00 +00004742 *inode_number = le64_to_cpu(pfinfo->UniqueId);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004743 }
4744 }
4745GetInodeNumOut:
4746 cifs_buf_release(pSMB);
4747 if (rc == -EAGAIN)
4748 goto GetInodeNumberRetry;
4749 return rc;
4750}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004751
Igor Mammedovfec45852008-05-16 13:06:30 +04004752/* parses DFS refferal V3 structure
4753 * caller is responsible for freeing target_nodes
4754 * returns:
4755 * on success - 0
4756 * on failure - errno
4757 */
4758static int
Steve Frencha1fe78f2008-05-16 18:48:38 +00004759parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
Igor Mammedovfec45852008-05-16 13:06:30 +04004760 unsigned int *num_of_nodes,
4761 struct dfs_info3_param **target_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004762 const struct nls_table *nls_codepage, int remap,
4763 const char *searchName)
Igor Mammedovfec45852008-05-16 13:06:30 +04004764{
4765 int i, rc = 0;
4766 char *data_end;
4767 bool is_unicode;
4768 struct dfs_referral_level_3 *ref;
4769
Harvey Harrison5ca33c62008-07-23 17:45:58 -07004770 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4771 is_unicode = true;
4772 else
4773 is_unicode = false;
Igor Mammedovfec45852008-05-16 13:06:30 +04004774 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4775
4776 if (*num_of_nodes < 1) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004777 cERROR(1, "num_referrals: must be at least > 0,"
4778 "but we get num_referrals = %d\n", *num_of_nodes);
Igor Mammedovfec45852008-05-16 13:06:30 +04004779 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004780 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004781 }
4782
4783 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
Al Viro1d92cfd2008-06-02 10:59:02 +01004784 if (ref->VersionNumber != cpu_to_le16(3)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004785 cERROR(1, "Referrals of V%d version are not supported,"
4786 "should be V3", le16_to_cpu(ref->VersionNumber));
Igor Mammedovfec45852008-05-16 13:06:30 +04004787 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004788 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004789 }
4790
4791 /* get the upper boundary of the resp buffer */
4792 data_end = (char *)(&(pSMBr->PathConsumed)) +
4793 le16_to_cpu(pSMBr->t2.DataCount);
4794
Steve Frenchf19159d2010-04-21 04:12:10 +00004795 cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
Igor Mammedovfec45852008-05-16 13:06:30 +04004796 *num_of_nodes,
Joe Perchesb6b38f72010-04-21 03:50:45 +00004797 le32_to_cpu(pSMBr->DFSFlags));
Igor Mammedovfec45852008-05-16 13:06:30 +04004798
4799 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
4800 *num_of_nodes, GFP_KERNEL);
4801 if (*target_nodes == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004802 cERROR(1, "Failed to allocate buffer for target_nodes\n");
Igor Mammedovfec45852008-05-16 13:06:30 +04004803 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004804 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004805 }
4806
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08004807 /* collect necessary data from referrals */
Igor Mammedovfec45852008-05-16 13:06:30 +04004808 for (i = 0; i < *num_of_nodes; i++) {
4809 char *temp;
4810 int max_len;
4811 struct dfs_info3_param *node = (*target_nodes)+i;
4812
Steve French0e0d2cf2009-05-01 05:27:32 +00004813 node->flags = le32_to_cpu(pSMBr->DFSFlags);
Igor Mammedov2c556082008-10-23 13:58:42 +04004814 if (is_unicode) {
Jeff Layton331c3132008-12-17 06:31:53 -05004815 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4816 GFP_KERNEL);
Steve French2920ee22009-08-31 15:27:26 +00004817 if (tmp == NULL) {
4818 rc = -ENOMEM;
4819 goto parse_DFS_referrals_exit;
4820 }
Steve Frenchacbbb762012-01-18 22:32:33 -06004821 cifsConvertToUTF16((__le16 *) tmp, searchName,
4822 PATH_MAX, nls_codepage, remap);
4823 node->path_consumed = cifs_utf16_bytes(tmp,
Jeff Layton69f801f2009-04-30 06:46:32 -04004824 le16_to_cpu(pSMBr->PathConsumed),
Igor Mammedov2c556082008-10-23 13:58:42 +04004825 nls_codepage);
4826 kfree(tmp);
4827 } else
4828 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4829
Igor Mammedovfec45852008-05-16 13:06:30 +04004830 node->server_type = le16_to_cpu(ref->ServerType);
4831 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4832
4833 /* copy DfsPath */
4834 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4835 max_len = data_end - temp;
Steve Frenchacbbb762012-01-18 22:32:33 -06004836 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4837 is_unicode, nls_codepage);
Jeff Laytond8e2f532009-05-14 07:46:59 -04004838 if (!node->path_name) {
4839 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004840 goto parse_DFS_referrals_exit;
Jeff Layton066ce682009-04-30 07:16:14 -04004841 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004842
4843 /* copy link target UNC */
4844 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4845 max_len = data_end - temp;
Steve Frenchacbbb762012-01-18 22:32:33 -06004846 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4847 is_unicode, nls_codepage);
Jeff Laytond8e2f532009-05-14 07:46:59 -04004848 if (!node->node_name)
4849 rc = -ENOMEM;
Igor Mammedovfec45852008-05-16 13:06:30 +04004850 }
4851
Steve Frencha1fe78f2008-05-16 18:48:38 +00004852parse_DFS_referrals_exit:
Igor Mammedovfec45852008-05-16 13:06:30 +04004853 if (rc) {
4854 free_dfs_info_array(*target_nodes, *num_of_nodes);
4855 *target_nodes = NULL;
4856 *num_of_nodes = 0;
4857 }
4858 return rc;
4859}
4860
Linus Torvalds1da177e2005-04-16 15:20:36 -07004861int
Steve French96daf2b2011-05-27 04:34:02 +00004862CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004863 const unsigned char *searchName,
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004864 struct dfs_info3_param **target_nodes,
4865 unsigned int *num_of_nodes,
Steve French737b7582005-04-28 22:41:06 -07004866 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004867{
4868/* TRANS2_GET_DFS_REFERRAL */
4869 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4870 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004871 int rc = 0;
4872 int bytes_returned;
4873 int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004874 __u16 params, byte_count;
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004875 *num_of_nodes = 0;
4876 *target_nodes = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004877
Joe Perchesb6b38f72010-04-21 03:50:45 +00004878 cFYI(1, "In GetDFSRefer the path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004879 if (ses == NULL)
4880 return -ENODEV;
4881getDFSRetry:
4882 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4883 (void **) &pSMBr);
4884 if (rc)
4885 return rc;
Steve French50c2f752007-07-13 00:33:32 +00004886
4887 /* server pointer checked in called function,
Steve French1982c342005-08-17 12:38:22 -07004888 but should never be null here anyway */
4889 pSMB->hdr.Mid = GetNextMid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004890 pSMB->hdr.Tid = ses->ipc_tid;
4891 pSMB->hdr.Uid = ses->Suid;
Steve French26f57362007-08-30 22:09:15 +00004892 if (ses->capabilities & CAP_STATUS32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004893 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
Steve French26f57362007-08-30 22:09:15 +00004894 if (ses->capabilities & CAP_DFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004895 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004896
4897 if (ses->capabilities & CAP_UNICODE) {
4898 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4899 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004900 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4901 searchName, PATH_MAX, nls_codepage,
4902 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004903 name_len++; /* trailing null */
4904 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004905 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004906 name_len = strnlen(searchName, PATH_MAX);
4907 name_len++; /* trailing null */
4908 strncpy(pSMB->RequestFileName, searchName, name_len);
4909 }
4910
Steve French790fe572007-07-07 19:25:05 +00004911 if (ses->server) {
Steve French96daf2b2011-05-27 04:34:02 +00004912 if (ses->server->sec_mode &
Steve French1a4e15a2006-10-12 21:33:51 +00004913 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4914 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4915 }
4916
Steve French50c2f752007-07-13 00:33:32 +00004917 pSMB->hdr.Uid = ses->Suid;
Steve French1a4e15a2006-10-12 21:33:51 +00004918
Linus Torvalds1da177e2005-04-16 15:20:36 -07004919 params = 2 /* level */ + name_len /*includes null */ ;
4920 pSMB->TotalDataCount = 0;
4921 pSMB->DataCount = 0;
4922 pSMB->DataOffset = 0;
4923 pSMB->MaxParameterCount = 0;
Steve French582d21e2008-05-13 04:54:12 +00004924 /* BB find exact max SMB PDU from sess structure BB */
4925 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004926 pSMB->MaxSetupCount = 0;
4927 pSMB->Reserved = 0;
4928 pSMB->Flags = 0;
4929 pSMB->Timeout = 0;
4930 pSMB->Reserved2 = 0;
4931 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004932 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004933 pSMB->SetupCount = 1;
4934 pSMB->Reserved3 = 0;
4935 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4936 byte_count = params + 3 /* pad */ ;
4937 pSMB->ParameterCount = cpu_to_le16(params);
4938 pSMB->TotalParameterCount = pSMB->ParameterCount;
4939 pSMB->MaxReferralLevel = cpu_to_le16(3);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004940 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004941 pSMB->ByteCount = cpu_to_le16(byte_count);
4942
4943 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4944 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4945 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00004946 cFYI(1, "Send error in GetDFSRefer = %d", rc);
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004947 goto GetDFSRefExit;
4948 }
4949 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004950
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004951 /* BB Also check if enough total bytes returned? */
Jeff Layton820a8032011-05-04 08:05:26 -04004952 if (rc || get_bcc(&pSMBr->hdr) < 17) {
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004953 rc = -EIO; /* bad smb */
Igor Mammedovfec45852008-05-16 13:06:30 +04004954 goto GetDFSRefExit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004955 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004956
Joe Perchesb6b38f72010-04-21 03:50:45 +00004957 cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
Jeff Layton820a8032011-05-04 08:05:26 -04004958 get_bcc(&pSMBr->hdr),
Joe Perchesb6b38f72010-04-21 03:50:45 +00004959 le16_to_cpu(pSMBr->t2.DataOffset));
Igor Mammedovfec45852008-05-16 13:06:30 +04004960
4961 /* parse returned result into more usable form */
Steve Frencha1fe78f2008-05-16 18:48:38 +00004962 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004963 target_nodes, nls_codepage, remap,
4964 searchName);
Igor Mammedovfec45852008-05-16 13:06:30 +04004965
Linus Torvalds1da177e2005-04-16 15:20:36 -07004966GetDFSRefExit:
Steve French0d817bc2008-05-22 02:02:03 +00004967 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004968
4969 if (rc == -EAGAIN)
4970 goto getDFSRetry;
4971
4972 return rc;
4973}
4974
Steve French20962432005-09-21 22:05:57 -07004975/* Query File System Info such as free space to old servers such as Win 9x */
4976int
Steve French96daf2b2011-05-27 04:34:02 +00004977SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
Steve French20962432005-09-21 22:05:57 -07004978{
4979/* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4980 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4981 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4982 FILE_SYSTEM_ALLOC_INFO *response_data;
4983 int rc = 0;
4984 int bytes_returned = 0;
4985 __u16 params, byte_count;
4986
Joe Perchesb6b38f72010-04-21 03:50:45 +00004987 cFYI(1, "OldQFSInfo");
Steve French20962432005-09-21 22:05:57 -07004988oldQFSInfoRetry:
4989 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4990 (void **) &pSMBr);
4991 if (rc)
4992 return rc;
Steve French20962432005-09-21 22:05:57 -07004993
4994 params = 2; /* level */
4995 pSMB->TotalDataCount = 0;
4996 pSMB->MaxParameterCount = cpu_to_le16(2);
4997 pSMB->MaxDataCount = cpu_to_le16(1000);
4998 pSMB->MaxSetupCount = 0;
4999 pSMB->Reserved = 0;
5000 pSMB->Flags = 0;
5001 pSMB->Timeout = 0;
5002 pSMB->Reserved2 = 0;
5003 byte_count = params + 1 /* pad */ ;
5004 pSMB->TotalParameterCount = cpu_to_le16(params);
5005 pSMB->ParameterCount = pSMB->TotalParameterCount;
5006 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5007 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5008 pSMB->DataCount = 0;
5009 pSMB->DataOffset = 0;
5010 pSMB->SetupCount = 1;
5011 pSMB->Reserved3 = 0;
5012 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5013 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005014 inc_rfc1001_len(pSMB, byte_count);
Steve French20962432005-09-21 22:05:57 -07005015 pSMB->ByteCount = cpu_to_le16(byte_count);
5016
5017 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5018 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5019 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005020 cFYI(1, "Send error in QFSInfo = %d", rc);
Steve French20962432005-09-21 22:05:57 -07005021 } else { /* decode response */
5022 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5023
Jeff Layton820a8032011-05-04 08:05:26 -04005024 if (rc || get_bcc(&pSMBr->hdr) < 18)
Steve French20962432005-09-21 22:05:57 -07005025 rc = -EIO; /* bad smb */
5026 else {
5027 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Joe Perchesb6b38f72010-04-21 03:50:45 +00005028 cFYI(1, "qfsinf resp BCC: %d Offset %d",
Jeff Layton820a8032011-05-04 08:05:26 -04005029 get_bcc(&pSMBr->hdr), data_offset);
Steve French20962432005-09-21 22:05:57 -07005030
Steve French50c2f752007-07-13 00:33:32 +00005031 response_data = (FILE_SYSTEM_ALLOC_INFO *)
Steve French20962432005-09-21 22:05:57 -07005032 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5033 FSData->f_bsize =
5034 le16_to_cpu(response_data->BytesPerSector) *
5035 le32_to_cpu(response_data->
5036 SectorsPerAllocationUnit);
5037 FSData->f_blocks =
Steve French50c2f752007-07-13 00:33:32 +00005038 le32_to_cpu(response_data->TotalAllocationUnits);
Steve French20962432005-09-21 22:05:57 -07005039 FSData->f_bfree = FSData->f_bavail =
5040 le32_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesb6b38f72010-04-21 03:50:45 +00005041 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5042 (unsigned long long)FSData->f_blocks,
5043 (unsigned long long)FSData->f_bfree,
5044 FSData->f_bsize);
Steve French20962432005-09-21 22:05:57 -07005045 }
5046 }
5047 cifs_buf_release(pSMB);
5048
5049 if (rc == -EAGAIN)
5050 goto oldQFSInfoRetry;
5051
5052 return rc;
5053}
5054
Linus Torvalds1da177e2005-04-16 15:20:36 -07005055int
Steve French96daf2b2011-05-27 04:34:02 +00005056CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005057{
5058/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5059 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5060 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5061 FILE_SYSTEM_INFO *response_data;
5062 int rc = 0;
5063 int bytes_returned = 0;
5064 __u16 params, byte_count;
5065
Joe Perchesb6b38f72010-04-21 03:50:45 +00005066 cFYI(1, "In QFSInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005067QFSInfoRetry:
5068 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5069 (void **) &pSMBr);
5070 if (rc)
5071 return rc;
5072
5073 params = 2; /* level */
5074 pSMB->TotalDataCount = 0;
5075 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French20962432005-09-21 22:05:57 -07005076 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005077 pSMB->MaxSetupCount = 0;
5078 pSMB->Reserved = 0;
5079 pSMB->Flags = 0;
5080 pSMB->Timeout = 0;
5081 pSMB->Reserved2 = 0;
5082 byte_count = params + 1 /* pad */ ;
5083 pSMB->TotalParameterCount = cpu_to_le16(params);
5084 pSMB->ParameterCount = pSMB->TotalParameterCount;
5085 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005086 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005087 pSMB->DataCount = 0;
5088 pSMB->DataOffset = 0;
5089 pSMB->SetupCount = 1;
5090 pSMB->Reserved3 = 0;
5091 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5092 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005093 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005094 pSMB->ByteCount = cpu_to_le16(byte_count);
5095
5096 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5097 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5098 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005099 cFYI(1, "Send error in QFSInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005100 } else { /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00005101 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005102
Jeff Layton820a8032011-05-04 08:05:26 -04005103 if (rc || get_bcc(&pSMBr->hdr) < 24)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005104 rc = -EIO; /* bad smb */
5105 else {
5106 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005107
5108 response_data =
5109 (FILE_SYSTEM_INFO
5110 *) (((char *) &pSMBr->hdr.Protocol) +
5111 data_offset);
5112 FSData->f_bsize =
5113 le32_to_cpu(response_data->BytesPerSector) *
5114 le32_to_cpu(response_data->
5115 SectorsPerAllocationUnit);
5116 FSData->f_blocks =
5117 le64_to_cpu(response_data->TotalAllocationUnits);
5118 FSData->f_bfree = FSData->f_bavail =
5119 le64_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesb6b38f72010-04-21 03:50:45 +00005120 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5121 (unsigned long long)FSData->f_blocks,
5122 (unsigned long long)FSData->f_bfree,
5123 FSData->f_bsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005124 }
5125 }
5126 cifs_buf_release(pSMB);
5127
5128 if (rc == -EAGAIN)
5129 goto QFSInfoRetry;
5130
5131 return rc;
5132}
5133
5134int
Steve French96daf2b2011-05-27 04:34:02 +00005135CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005136{
5137/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5138 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5139 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5140 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5141 int rc = 0;
5142 int bytes_returned = 0;
5143 __u16 params, byte_count;
5144
Joe Perchesb6b38f72010-04-21 03:50:45 +00005145 cFYI(1, "In QFSAttributeInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005146QFSAttributeRetry:
5147 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5148 (void **) &pSMBr);
5149 if (rc)
5150 return rc;
5151
5152 params = 2; /* level */
5153 pSMB->TotalDataCount = 0;
5154 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005155 /* BB find exact max SMB PDU from sess structure BB */
5156 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005157 pSMB->MaxSetupCount = 0;
5158 pSMB->Reserved = 0;
5159 pSMB->Flags = 0;
5160 pSMB->Timeout = 0;
5161 pSMB->Reserved2 = 0;
5162 byte_count = params + 1 /* pad */ ;
5163 pSMB->TotalParameterCount = cpu_to_le16(params);
5164 pSMB->ParameterCount = pSMB->TotalParameterCount;
5165 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005166 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005167 pSMB->DataCount = 0;
5168 pSMB->DataOffset = 0;
5169 pSMB->SetupCount = 1;
5170 pSMB->Reserved3 = 0;
5171 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5172 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005173 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005174 pSMB->ByteCount = cpu_to_le16(byte_count);
5175
5176 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5177 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5178 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005179 cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005180 } else { /* decode response */
5181 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5182
Jeff Layton820a8032011-05-04 08:05:26 -04005183 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Steve French50c2f752007-07-13 00:33:32 +00005184 /* BB also check if enough bytes returned */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005185 rc = -EIO; /* bad smb */
5186 } else {
5187 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5188 response_data =
5189 (FILE_SYSTEM_ATTRIBUTE_INFO
5190 *) (((char *) &pSMBr->hdr.Protocol) +
5191 data_offset);
5192 memcpy(&tcon->fsAttrInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005193 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005194 }
5195 }
5196 cifs_buf_release(pSMB);
5197
5198 if (rc == -EAGAIN)
5199 goto QFSAttributeRetry;
5200
5201 return rc;
5202}
5203
5204int
Steve French96daf2b2011-05-27 04:34:02 +00005205CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005206{
5207/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5208 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5209 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5210 FILE_SYSTEM_DEVICE_INFO *response_data;
5211 int rc = 0;
5212 int bytes_returned = 0;
5213 __u16 params, byte_count;
5214
Joe Perchesb6b38f72010-04-21 03:50:45 +00005215 cFYI(1, "In QFSDeviceInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005216QFSDeviceRetry:
5217 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5218 (void **) &pSMBr);
5219 if (rc)
5220 return rc;
5221
5222 params = 2; /* level */
5223 pSMB->TotalDataCount = 0;
5224 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005225 /* BB find exact max SMB PDU from sess structure BB */
5226 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005227 pSMB->MaxSetupCount = 0;
5228 pSMB->Reserved = 0;
5229 pSMB->Flags = 0;
5230 pSMB->Timeout = 0;
5231 pSMB->Reserved2 = 0;
5232 byte_count = params + 1 /* pad */ ;
5233 pSMB->TotalParameterCount = cpu_to_le16(params);
5234 pSMB->ParameterCount = pSMB->TotalParameterCount;
5235 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005236 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005237
5238 pSMB->DataCount = 0;
5239 pSMB->DataOffset = 0;
5240 pSMB->SetupCount = 1;
5241 pSMB->Reserved3 = 0;
5242 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5243 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005244 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005245 pSMB->ByteCount = cpu_to_le16(byte_count);
5246
5247 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5248 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5249 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005250 cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005251 } else { /* decode response */
5252 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5253
Jeff Layton820a8032011-05-04 08:05:26 -04005254 if (rc || get_bcc(&pSMBr->hdr) <
5255 sizeof(FILE_SYSTEM_DEVICE_INFO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005256 rc = -EIO; /* bad smb */
5257 else {
5258 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5259 response_data =
Steve French737b7582005-04-28 22:41:06 -07005260 (FILE_SYSTEM_DEVICE_INFO *)
5261 (((char *) &pSMBr->hdr.Protocol) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07005262 data_offset);
5263 memcpy(&tcon->fsDevInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005264 sizeof(FILE_SYSTEM_DEVICE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005265 }
5266 }
5267 cifs_buf_release(pSMB);
5268
5269 if (rc == -EAGAIN)
5270 goto QFSDeviceRetry;
5271
5272 return rc;
5273}
5274
5275int
Steve French96daf2b2011-05-27 04:34:02 +00005276CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005277{
5278/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5279 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5280 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5281 FILE_SYSTEM_UNIX_INFO *response_data;
5282 int rc = 0;
5283 int bytes_returned = 0;
5284 __u16 params, byte_count;
5285
Joe Perchesb6b38f72010-04-21 03:50:45 +00005286 cFYI(1, "In QFSUnixInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005287QFSUnixRetry:
Jeff Laytonf5695992010-09-29 15:27:08 -04005288 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5289 (void **) &pSMB, (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005290 if (rc)
5291 return rc;
5292
5293 params = 2; /* level */
5294 pSMB->TotalDataCount = 0;
5295 pSMB->DataCount = 0;
5296 pSMB->DataOffset = 0;
5297 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005298 /* BB find exact max SMB PDU from sess structure BB */
5299 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005300 pSMB->MaxSetupCount = 0;
5301 pSMB->Reserved = 0;
5302 pSMB->Flags = 0;
5303 pSMB->Timeout = 0;
5304 pSMB->Reserved2 = 0;
5305 byte_count = params + 1 /* pad */ ;
5306 pSMB->ParameterCount = cpu_to_le16(params);
5307 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005308 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5309 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005310 pSMB->SetupCount = 1;
5311 pSMB->Reserved3 = 0;
5312 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5313 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005314 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005315 pSMB->ByteCount = cpu_to_le16(byte_count);
5316
5317 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5318 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5319 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005320 cERROR(1, "Send error in QFSUnixInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005321 } else { /* decode response */
5322 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5323
Jeff Layton820a8032011-05-04 08:05:26 -04005324 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005325 rc = -EIO; /* bad smb */
5326 } else {
5327 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5328 response_data =
5329 (FILE_SYSTEM_UNIX_INFO
5330 *) (((char *) &pSMBr->hdr.Protocol) +
5331 data_offset);
5332 memcpy(&tcon->fsUnixInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005333 sizeof(FILE_SYSTEM_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005334 }
5335 }
5336 cifs_buf_release(pSMB);
5337
5338 if (rc == -EAGAIN)
5339 goto QFSUnixRetry;
5340
5341
5342 return rc;
5343}
5344
Jeremy Allisonac670552005-06-22 17:26:35 -07005345int
Steve French96daf2b2011-05-27 04:34:02 +00005346CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
Jeremy Allisonac670552005-06-22 17:26:35 -07005347{
5348/* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5349 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5350 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5351 int rc = 0;
5352 int bytes_returned = 0;
5353 __u16 params, param_offset, offset, byte_count;
5354
Joe Perchesb6b38f72010-04-21 03:50:45 +00005355 cFYI(1, "In SETFSUnixInfo");
Jeremy Allisonac670552005-06-22 17:26:35 -07005356SETFSUnixRetry:
Steve Frenchf26282c2006-03-01 09:17:37 +00005357 /* BB switch to small buf init to save memory */
Jeff Laytonf5695992010-09-29 15:27:08 -04005358 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5359 (void **) &pSMB, (void **) &pSMBr);
Jeremy Allisonac670552005-06-22 17:26:35 -07005360 if (rc)
5361 return rc;
5362
5363 params = 4; /* 2 bytes zero followed by info level. */
5364 pSMB->MaxSetupCount = 0;
5365 pSMB->Reserved = 0;
5366 pSMB->Flags = 0;
5367 pSMB->Timeout = 0;
5368 pSMB->Reserved2 = 0;
Steve French50c2f752007-07-13 00:33:32 +00005369 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5370 - 4;
Jeremy Allisonac670552005-06-22 17:26:35 -07005371 offset = param_offset + params;
5372
5373 pSMB->MaxParameterCount = cpu_to_le16(4);
Steve French582d21e2008-05-13 04:54:12 +00005374 /* BB find exact max SMB PDU from sess structure BB */
5375 pSMB->MaxDataCount = cpu_to_le16(100);
Jeremy Allisonac670552005-06-22 17:26:35 -07005376 pSMB->SetupCount = 1;
5377 pSMB->Reserved3 = 0;
5378 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5379 byte_count = 1 /* pad */ + params + 12;
5380
5381 pSMB->DataCount = cpu_to_le16(12);
5382 pSMB->ParameterCount = cpu_to_le16(params);
5383 pSMB->TotalDataCount = pSMB->DataCount;
5384 pSMB->TotalParameterCount = pSMB->ParameterCount;
5385 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5386 pSMB->DataOffset = cpu_to_le16(offset);
5387
5388 /* Params. */
5389 pSMB->FileNum = 0;
5390 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5391
5392 /* Data. */
5393 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5394 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5395 pSMB->ClientUnixCap = cpu_to_le64(cap);
5396
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005397 inc_rfc1001_len(pSMB, byte_count);
Jeremy Allisonac670552005-06-22 17:26:35 -07005398 pSMB->ByteCount = cpu_to_le16(byte_count);
5399
5400 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5401 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5402 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005403 cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
Jeremy Allisonac670552005-06-22 17:26:35 -07005404 } else { /* decode response */
5405 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve Frenchad7a2922008-02-07 23:25:02 +00005406 if (rc)
Jeremy Allisonac670552005-06-22 17:26:35 -07005407 rc = -EIO; /* bad smb */
Jeremy Allisonac670552005-06-22 17:26:35 -07005408 }
5409 cifs_buf_release(pSMB);
5410
5411 if (rc == -EAGAIN)
5412 goto SETFSUnixRetry;
5413
5414 return rc;
5415}
5416
5417
Linus Torvalds1da177e2005-04-16 15:20:36 -07005418
5419int
Steve French96daf2b2011-05-27 04:34:02 +00005420CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
Steve French737b7582005-04-28 22:41:06 -07005421 struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005422{
5423/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5424 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5425 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5426 FILE_SYSTEM_POSIX_INFO *response_data;
5427 int rc = 0;
5428 int bytes_returned = 0;
5429 __u16 params, byte_count;
5430
Joe Perchesb6b38f72010-04-21 03:50:45 +00005431 cFYI(1, "In QFSPosixInfo");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005432QFSPosixRetry:
5433 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5434 (void **) &pSMBr);
5435 if (rc)
5436 return rc;
5437
5438 params = 2; /* level */
5439 pSMB->TotalDataCount = 0;
5440 pSMB->DataCount = 0;
5441 pSMB->DataOffset = 0;
5442 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005443 /* BB find exact max SMB PDU from sess structure BB */
5444 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005445 pSMB->MaxSetupCount = 0;
5446 pSMB->Reserved = 0;
5447 pSMB->Flags = 0;
5448 pSMB->Timeout = 0;
5449 pSMB->Reserved2 = 0;
5450 byte_count = params + 1 /* pad */ ;
5451 pSMB->ParameterCount = cpu_to_le16(params);
5452 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005453 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5454 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005455 pSMB->SetupCount = 1;
5456 pSMB->Reserved3 = 0;
5457 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5458 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005459 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005460 pSMB->ByteCount = cpu_to_le16(byte_count);
5461
5462 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5463 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5464 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005465 cFYI(1, "Send error in QFSUnixInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005466 } else { /* decode response */
5467 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5468
Jeff Layton820a8032011-05-04 08:05:26 -04005469 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005470 rc = -EIO; /* bad smb */
5471 } else {
5472 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5473 response_data =
5474 (FILE_SYSTEM_POSIX_INFO
5475 *) (((char *) &pSMBr->hdr.Protocol) +
5476 data_offset);
5477 FSData->f_bsize =
5478 le32_to_cpu(response_data->BlockSize);
5479 FSData->f_blocks =
5480 le64_to_cpu(response_data->TotalBlocks);
5481 FSData->f_bfree =
5482 le64_to_cpu(response_data->BlocksAvail);
Steve French790fe572007-07-07 19:25:05 +00005483 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005484 FSData->f_bavail = FSData->f_bfree;
5485 } else {
5486 FSData->f_bavail =
Steve French50c2f752007-07-13 00:33:32 +00005487 le64_to_cpu(response_data->UserBlocksAvail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005488 }
Steve French790fe572007-07-07 19:25:05 +00005489 if (response_data->TotalFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005490 FSData->f_files =
Steve French50c2f752007-07-13 00:33:32 +00005491 le64_to_cpu(response_data->TotalFileNodes);
Steve French790fe572007-07-07 19:25:05 +00005492 if (response_data->FreeFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005493 FSData->f_ffree =
Steve French50c2f752007-07-13 00:33:32 +00005494 le64_to_cpu(response_data->FreeFileNodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005495 }
5496 }
5497 cifs_buf_release(pSMB);
5498
5499 if (rc == -EAGAIN)
5500 goto QFSPosixRetry;
5501
5502 return rc;
5503}
5504
5505
Steve French50c2f752007-07-13 00:33:32 +00005506/* We can not use write of zero bytes trick to
5507 set file size due to need for large file support. Also note that
5508 this SetPathInfo is preferred to SetFileInfo based method in next
Linus Torvalds1da177e2005-04-16 15:20:36 -07005509 routine which is only needed to work around a sharing violation bug
5510 in Samba which this routine can run into */
5511
5512int
Steve French96daf2b2011-05-27 04:34:02 +00005513CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French4b18f2a2008-04-29 00:06:05 +00005514 __u64 size, bool SetAllocation,
Steve French737b7582005-04-28 22:41:06 -07005515 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005516{
5517 struct smb_com_transaction2_spi_req *pSMB = NULL;
5518 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5519 struct file_end_of_file_info *parm_data;
5520 int name_len;
5521 int rc = 0;
5522 int bytes_returned = 0;
5523 __u16 params, byte_count, data_count, param_offset, offset;
5524
Joe Perchesb6b38f72010-04-21 03:50:45 +00005525 cFYI(1, "In SetEOF");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005526SetEOFRetry:
5527 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5528 (void **) &pSMBr);
5529 if (rc)
5530 return rc;
5531
5532 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5533 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06005534 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5535 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005536 name_len++; /* trailing null */
5537 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07005538 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005539 name_len = strnlen(fileName, PATH_MAX);
5540 name_len++; /* trailing null */
5541 strncpy(pSMB->FileName, fileName, name_len);
5542 }
5543 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005544 data_count = sizeof(struct file_end_of_file_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005545 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French3e87d802005-09-18 20:49:21 -07005546 pSMB->MaxDataCount = cpu_to_le16(4100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005547 pSMB->MaxSetupCount = 0;
5548 pSMB->Reserved = 0;
5549 pSMB->Flags = 0;
5550 pSMB->Timeout = 0;
5551 pSMB->Reserved2 = 0;
5552 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005553 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005554 offset = param_offset + params;
Steve French790fe572007-07-07 19:25:05 +00005555 if (SetAllocation) {
Steve French50c2f752007-07-13 00:33:32 +00005556 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5557 pSMB->InformationLevel =
5558 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5559 else
5560 pSMB->InformationLevel =
5561 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5562 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005563 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5564 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005565 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005566 else
5567 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005568 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005569 }
5570
5571 parm_data =
5572 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5573 offset);
5574 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5575 pSMB->DataOffset = cpu_to_le16(offset);
5576 pSMB->SetupCount = 1;
5577 pSMB->Reserved3 = 0;
5578 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5579 byte_count = 3 /* pad */ + params + data_count;
5580 pSMB->DataCount = cpu_to_le16(data_count);
5581 pSMB->TotalDataCount = pSMB->DataCount;
5582 pSMB->ParameterCount = cpu_to_le16(params);
5583 pSMB->TotalParameterCount = pSMB->ParameterCount;
5584 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005585 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005586 parm_data->FileSize = cpu_to_le64(size);
5587 pSMB->ByteCount = cpu_to_le16(byte_count);
5588 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5589 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005590 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005591 cFYI(1, "SetPathInfo (file size) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005592
5593 cifs_buf_release(pSMB);
5594
5595 if (rc == -EAGAIN)
5596 goto SetEOFRetry;
5597
5598 return rc;
5599}
5600
5601int
Steve French96daf2b2011-05-27 04:34:02 +00005602CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
Steve French4b18f2a2008-04-29 00:06:05 +00005603 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005604{
5605 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005606 struct file_end_of_file_info *parm_data;
5607 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005608 __u16 params, param_offset, offset, byte_count, count;
5609
Joe Perchesb6b38f72010-04-21 03:50:45 +00005610 cFYI(1, "SetFileSize (via SetFileInfo) %lld",
5611 (long long)size);
Steve Frenchcd634992005-04-28 22:41:10 -07005612 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5613
Linus Torvalds1da177e2005-04-16 15:20:36 -07005614 if (rc)
5615 return rc;
5616
5617 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5618 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005619
Linus Torvalds1da177e2005-04-16 15:20:36 -07005620 params = 6;
5621 pSMB->MaxSetupCount = 0;
5622 pSMB->Reserved = 0;
5623 pSMB->Flags = 0;
5624 pSMB->Timeout = 0;
5625 pSMB->Reserved2 = 0;
5626 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5627 offset = param_offset + params;
5628
Linus Torvalds1da177e2005-04-16 15:20:36 -07005629 count = sizeof(struct file_end_of_file_info);
5630 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005631 /* BB find exact max SMB PDU from sess structure BB */
5632 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005633 pSMB->SetupCount = 1;
5634 pSMB->Reserved3 = 0;
5635 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5636 byte_count = 3 /* pad */ + params + count;
5637 pSMB->DataCount = cpu_to_le16(count);
5638 pSMB->ParameterCount = cpu_to_le16(params);
5639 pSMB->TotalDataCount = pSMB->DataCount;
5640 pSMB->TotalParameterCount = pSMB->ParameterCount;
5641 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5642 parm_data =
Steve French50c2f752007-07-13 00:33:32 +00005643 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5644 + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005645 pSMB->DataOffset = cpu_to_le16(offset);
5646 parm_data->FileSize = cpu_to_le64(size);
5647 pSMB->Fid = fid;
Steve French790fe572007-07-07 19:25:05 +00005648 if (SetAllocation) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005649 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5650 pSMB->InformationLevel =
5651 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5652 else
5653 pSMB->InformationLevel =
5654 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
Steve French50c2f752007-07-13 00:33:32 +00005655 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005656 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5657 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005658 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005659 else
5660 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005661 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005662 }
5663 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005664 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005665 pSMB->ByteCount = cpu_to_le16(byte_count);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005666 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005667 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00005668 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005669 }
5670
Steve French50c2f752007-07-13 00:33:32 +00005671 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005672 since file handle passed in no longer valid */
5673
5674 return rc;
5675}
5676
Steve French50c2f752007-07-13 00:33:32 +00005677/* Some legacy servers such as NT4 require that the file times be set on
Linus Torvalds1da177e2005-04-16 15:20:36 -07005678 an open handle, rather than by pathname - this is awkward due to
5679 potential access conflicts on the open, but it is unavoidable for these
5680 old servers since the only other choice is to go from 100 nanosecond DCE
5681 time and resort to the original setpathinfo level which takes the ancient
5682 DOS time format with 2 second granularity */
5683int
Steve French96daf2b2011-05-27 04:34:02 +00005684CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005685 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005686{
5687 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005688 char *data_offset;
5689 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005690 __u16 params, param_offset, offset, byte_count, count;
5691
Joe Perchesb6b38f72010-04-21 03:50:45 +00005692 cFYI(1, "Set Times (via SetFileInfo)");
Steve Frenchcd634992005-04-28 22:41:10 -07005693 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5694
Linus Torvalds1da177e2005-04-16 15:20:36 -07005695 if (rc)
5696 return rc;
5697
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005698 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5699 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005700
Linus Torvalds1da177e2005-04-16 15:20:36 -07005701 params = 6;
5702 pSMB->MaxSetupCount = 0;
5703 pSMB->Reserved = 0;
5704 pSMB->Flags = 0;
5705 pSMB->Timeout = 0;
5706 pSMB->Reserved2 = 0;
5707 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5708 offset = param_offset + params;
5709
Steve French50c2f752007-07-13 00:33:32 +00005710 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005711
Steve French26f57362007-08-30 22:09:15 +00005712 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005713 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005714 /* BB find max SMB PDU from sess */
5715 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005716 pSMB->SetupCount = 1;
5717 pSMB->Reserved3 = 0;
5718 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5719 byte_count = 3 /* pad */ + params + count;
5720 pSMB->DataCount = cpu_to_le16(count);
5721 pSMB->ParameterCount = cpu_to_le16(params);
5722 pSMB->TotalDataCount = pSMB->DataCount;
5723 pSMB->TotalParameterCount = pSMB->ParameterCount;
5724 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5725 pSMB->DataOffset = cpu_to_le16(offset);
5726 pSMB->Fid = fid;
5727 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5728 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5729 else
5730 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5731 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005732 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005733 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00005734 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005735 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005736 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005737 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005738
Steve French50c2f752007-07-13 00:33:32 +00005739 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005740 since file handle passed in no longer valid */
5741
5742 return rc;
5743}
5744
Jeff Layton6d22f092008-09-23 11:48:35 -04005745int
Steve French96daf2b2011-05-27 04:34:02 +00005746CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
Jeff Layton6d22f092008-09-23 11:48:35 -04005747 bool delete_file, __u16 fid, __u32 pid_of_opener)
5748{
5749 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5750 char *data_offset;
5751 int rc = 0;
5752 __u16 params, param_offset, offset, byte_count, count;
5753
Joe Perchesb6b38f72010-04-21 03:50:45 +00005754 cFYI(1, "Set File Disposition (via SetFileInfo)");
Jeff Layton6d22f092008-09-23 11:48:35 -04005755 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5756
5757 if (rc)
5758 return rc;
5759
5760 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5761 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5762
5763 params = 6;
5764 pSMB->MaxSetupCount = 0;
5765 pSMB->Reserved = 0;
5766 pSMB->Flags = 0;
5767 pSMB->Timeout = 0;
5768 pSMB->Reserved2 = 0;
5769 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5770 offset = param_offset + params;
5771
5772 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5773
5774 count = 1;
5775 pSMB->MaxParameterCount = cpu_to_le16(2);
5776 /* BB find max SMB PDU from sess */
5777 pSMB->MaxDataCount = cpu_to_le16(1000);
5778 pSMB->SetupCount = 1;
5779 pSMB->Reserved3 = 0;
5780 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5781 byte_count = 3 /* pad */ + params + count;
5782 pSMB->DataCount = cpu_to_le16(count);
5783 pSMB->ParameterCount = cpu_to_le16(params);
5784 pSMB->TotalDataCount = pSMB->DataCount;
5785 pSMB->TotalParameterCount = pSMB->ParameterCount;
5786 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5787 pSMB->DataOffset = cpu_to_le16(offset);
5788 pSMB->Fid = fid;
5789 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5790 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005791 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton6d22f092008-09-23 11:48:35 -04005792 pSMB->ByteCount = cpu_to_le16(byte_count);
5793 *data_offset = delete_file ? 1 : 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005794 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Jeff Layton6d22f092008-09-23 11:48:35 -04005795 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005796 cFYI(1, "Send error in SetFileDisposition = %d", rc);
Jeff Layton6d22f092008-09-23 11:48:35 -04005797
5798 return rc;
5799}
Linus Torvalds1da177e2005-04-16 15:20:36 -07005800
5801int
Steve French96daf2b2011-05-27 04:34:02 +00005802CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton6fc000e2008-08-02 07:26:12 -04005803 const char *fileName, const FILE_BASIC_INFO *data,
5804 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005805{
5806 TRANSACTION2_SPI_REQ *pSMB = NULL;
5807 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5808 int name_len;
5809 int rc = 0;
5810 int bytes_returned = 0;
5811 char *data_offset;
5812 __u16 params, param_offset, offset, byte_count, count;
5813
Joe Perchesb6b38f72010-04-21 03:50:45 +00005814 cFYI(1, "In SetTimes");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005815
5816SetTimesRetry:
5817 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5818 (void **) &pSMBr);
5819 if (rc)
5820 return rc;
5821
5822 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5823 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06005824 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5825 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005826 name_len++; /* trailing null */
5827 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005828 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005829 name_len = strnlen(fileName, PATH_MAX);
5830 name_len++; /* trailing null */
5831 strncpy(pSMB->FileName, fileName, name_len);
5832 }
5833
5834 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005835 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005836 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005837 /* BB find max SMB PDU from sess structure BB */
5838 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005839 pSMB->MaxSetupCount = 0;
5840 pSMB->Reserved = 0;
5841 pSMB->Flags = 0;
5842 pSMB->Timeout = 0;
5843 pSMB->Reserved2 = 0;
5844 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005845 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005846 offset = param_offset + params;
5847 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5848 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5849 pSMB->DataOffset = cpu_to_le16(offset);
5850 pSMB->SetupCount = 1;
5851 pSMB->Reserved3 = 0;
5852 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5853 byte_count = 3 /* pad */ + params + count;
5854
5855 pSMB->DataCount = cpu_to_le16(count);
5856 pSMB->ParameterCount = cpu_to_le16(params);
5857 pSMB->TotalDataCount = pSMB->DataCount;
5858 pSMB->TotalParameterCount = pSMB->ParameterCount;
5859 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5860 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5861 else
5862 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5863 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005864 inc_rfc1001_len(pSMB, byte_count);
Steve French26f57362007-08-30 22:09:15 +00005865 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005866 pSMB->ByteCount = cpu_to_le16(byte_count);
5867 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5868 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005869 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005870 cFYI(1, "SetPathInfo (times) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005871
5872 cifs_buf_release(pSMB);
5873
5874 if (rc == -EAGAIN)
5875 goto SetTimesRetry;
5876
5877 return rc;
5878}
5879
5880/* Can not be used to set time stamps yet (due to old DOS time format) */
5881/* Can be used to set attributes */
5882#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5883 handling it anyway and NT4 was what we thought it would be needed for
5884 Do not delete it until we prove whether needed for Win9x though */
5885int
Steve French96daf2b2011-05-27 04:34:02 +00005886CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005887 __u16 dos_attrs, const struct nls_table *nls_codepage)
5888{
5889 SETATTR_REQ *pSMB = NULL;
5890 SETATTR_RSP *pSMBr = NULL;
5891 int rc = 0;
5892 int bytes_returned;
5893 int name_len;
5894
Joe Perchesb6b38f72010-04-21 03:50:45 +00005895 cFYI(1, "In SetAttrLegacy");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005896
5897SetAttrLgcyRetry:
5898 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5899 (void **) &pSMBr);
5900 if (rc)
5901 return rc;
5902
5903 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5904 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06005905 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5906 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005907 name_len++; /* trailing null */
5908 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005909 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005910 name_len = strnlen(fileName, PATH_MAX);
5911 name_len++; /* trailing null */
5912 strncpy(pSMB->fileName, fileName, name_len);
5913 }
5914 pSMB->attr = cpu_to_le16(dos_attrs);
5915 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005916 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005917 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5918 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5919 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005920 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00005921 cFYI(1, "Error in LegacySetAttr = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005922
5923 cifs_buf_release(pSMB);
5924
5925 if (rc == -EAGAIN)
5926 goto SetAttrLgcyRetry;
5927
5928 return rc;
5929}
5930#endif /* temporarily unneeded SetAttr legacy function */
5931
Jeff Layton654cf142009-07-09 20:02:49 -04005932static void
5933cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5934 const struct cifs_unix_set_info_args *args)
5935{
5936 u64 mode = args->mode;
5937
5938 /*
5939 * Samba server ignores set of file size to zero due to bugs in some
5940 * older clients, but we should be precise - we use SetFileSize to
5941 * set file size and do not want to truncate file size to zero
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005942 * accidentally as happened on one Samba server beta by putting
Jeff Layton654cf142009-07-09 20:02:49 -04005943 * zero instead of -1 here
5944 */
5945 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5946 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5947 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5948 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5949 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5950 data_offset->Uid = cpu_to_le64(args->uid);
5951 data_offset->Gid = cpu_to_le64(args->gid);
5952 /* better to leave device as zero when it is */
5953 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5954 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5955 data_offset->Permissions = cpu_to_le64(mode);
5956
5957 if (S_ISREG(mode))
5958 data_offset->Type = cpu_to_le32(UNIX_FILE);
5959 else if (S_ISDIR(mode))
5960 data_offset->Type = cpu_to_le32(UNIX_DIR);
5961 else if (S_ISLNK(mode))
5962 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5963 else if (S_ISCHR(mode))
5964 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5965 else if (S_ISBLK(mode))
5966 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5967 else if (S_ISFIFO(mode))
5968 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5969 else if (S_ISSOCK(mode))
5970 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5971}
5972
Linus Torvalds1da177e2005-04-16 15:20:36 -07005973int
Steve French96daf2b2011-05-27 04:34:02 +00005974CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005975 const struct cifs_unix_set_info_args *args,
5976 u16 fid, u32 pid_of_opener)
5977{
5978 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5979 FILE_UNIX_BASIC_INFO *data_offset;
5980 int rc = 0;
5981 u16 params, param_offset, offset, byte_count, count;
5982
Joe Perchesb6b38f72010-04-21 03:50:45 +00005983 cFYI(1, "Set Unix Info (via SetFileInfo)");
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005984 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5985
5986 if (rc)
5987 return rc;
5988
5989 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5990 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5991
5992 params = 6;
5993 pSMB->MaxSetupCount = 0;
5994 pSMB->Reserved = 0;
5995 pSMB->Flags = 0;
5996 pSMB->Timeout = 0;
5997 pSMB->Reserved2 = 0;
5998 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5999 offset = param_offset + params;
6000
6001 data_offset = (FILE_UNIX_BASIC_INFO *)
6002 ((char *)(&pSMB->hdr.Protocol) + offset);
6003 count = sizeof(FILE_UNIX_BASIC_INFO);
6004
6005 pSMB->MaxParameterCount = cpu_to_le16(2);
6006 /* BB find max SMB PDU from sess */
6007 pSMB->MaxDataCount = cpu_to_le16(1000);
6008 pSMB->SetupCount = 1;
6009 pSMB->Reserved3 = 0;
6010 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
6011 byte_count = 3 /* pad */ + params + count;
6012 pSMB->DataCount = cpu_to_le16(count);
6013 pSMB->ParameterCount = cpu_to_le16(params);
6014 pSMB->TotalDataCount = pSMB->DataCount;
6015 pSMB->TotalParameterCount = pSMB->ParameterCount;
6016 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6017 pSMB->DataOffset = cpu_to_le16(offset);
6018 pSMB->Fid = fid;
6019 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6020 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006021 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006022 pSMB->ByteCount = cpu_to_le16(byte_count);
6023
6024 cifs_fill_unix_set_info(data_offset, args);
6025
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04006026 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006027 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00006028 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006029
6030 /* Note: On -EAGAIN error only caller can retry on handle based calls
6031 since file handle passed in no longer valid */
6032
6033 return rc;
6034}
6035
6036int
Steve French96daf2b2011-05-27 04:34:02 +00006037CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
Jeff Layton01ea95e2009-07-09 20:02:49 -04006038 const struct cifs_unix_set_info_args *args,
6039 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006040{
6041 TRANSACTION2_SPI_REQ *pSMB = NULL;
6042 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6043 int name_len;
6044 int rc = 0;
6045 int bytes_returned = 0;
6046 FILE_UNIX_BASIC_INFO *data_offset;
6047 __u16 params, param_offset, offset, count, byte_count;
6048
Joe Perchesb6b38f72010-04-21 03:50:45 +00006049 cFYI(1, "In SetUID/GID/Mode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006050setPermsRetry:
6051 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6052 (void **) &pSMBr);
6053 if (rc)
6054 return rc;
6055
6056 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6057 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06006058 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6059 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006060 name_len++; /* trailing null */
6061 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07006062 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006063 name_len = strnlen(fileName, PATH_MAX);
6064 name_len++; /* trailing null */
6065 strncpy(pSMB->FileName, fileName, name_len);
6066 }
6067
6068 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00006069 count = sizeof(FILE_UNIX_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006070 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006071 /* BB find max SMB PDU from sess structure BB */
6072 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006073 pSMB->MaxSetupCount = 0;
6074 pSMB->Reserved = 0;
6075 pSMB->Flags = 0;
6076 pSMB->Timeout = 0;
6077 pSMB->Reserved2 = 0;
6078 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006079 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006080 offset = param_offset + params;
6081 data_offset =
6082 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6083 offset);
6084 memset(data_offset, 0, count);
6085 pSMB->DataOffset = cpu_to_le16(offset);
6086 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6087 pSMB->SetupCount = 1;
6088 pSMB->Reserved3 = 0;
6089 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6090 byte_count = 3 /* pad */ + params + count;
6091 pSMB->ParameterCount = cpu_to_le16(params);
6092 pSMB->DataCount = cpu_to_le16(count);
6093 pSMB->TotalParameterCount = pSMB->ParameterCount;
6094 pSMB->TotalDataCount = pSMB->DataCount;
6095 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6096 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006097 inc_rfc1001_len(pSMB, byte_count);
Steve French50c2f752007-07-13 00:33:32 +00006098
Jeff Layton654cf142009-07-09 20:02:49 -04006099 cifs_fill_unix_set_info(data_offset, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006100
6101 pSMB->ByteCount = cpu_to_le16(byte_count);
6102 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6103 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006104 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00006105 cFYI(1, "SetPathInfo (perms) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006106
Steve French0d817bc2008-05-22 02:02:03 +00006107 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006108 if (rc == -EAGAIN)
6109 goto setPermsRetry;
6110 return rc;
6111}
6112
Linus Torvalds1da177e2005-04-16 15:20:36 -07006113#ifdef CONFIG_CIFS_XATTR
Jeff Layton31c05192010-02-10 16:18:26 -05006114/*
6115 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6116 * function used by listxattr and getxattr type calls. When ea_name is set,
6117 * it looks for that attribute name and stuffs that value into the EAData
6118 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6119 * buffer. In both cases, the return value is either the length of the
6120 * resulting data or a negative error code. If EAData is a NULL pointer then
6121 * the data isn't copied to it, but the length is returned.
6122 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006123ssize_t
Steve French96daf2b2011-05-27 04:34:02 +00006124CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
Jeff Layton31c05192010-02-10 16:18:26 -05006125 const unsigned char *searchName, const unsigned char *ea_name,
6126 char *EAData, size_t buf_size,
6127 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006128{
6129 /* BB assumes one setup word */
6130 TRANSACTION2_QPI_REQ *pSMB = NULL;
6131 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6132 int rc = 0;
6133 int bytes_returned;
Jeff Layton6e462b92010-02-10 16:18:26 -05006134 int list_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006135 struct fealist *ea_response_data;
Steve French50c2f752007-07-13 00:33:32 +00006136 struct fea *temp_fea;
6137 char *temp_ptr;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006138 char *end_of_smb;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006139 __u16 params, byte_count, data_offset;
Jeff Layton5980fc92011-07-28 12:48:26 -04006140 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006141
Joe Perchesb6b38f72010-04-21 03:50:45 +00006142 cFYI(1, "In Query All EAs path %s", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006143QAllEAsRetry:
6144 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6145 (void **) &pSMBr);
6146 if (rc)
6147 return rc;
6148
6149 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Jeff Layton6e462b92010-02-10 16:18:26 -05006150 list_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06006151 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6152 PATH_MAX, nls_codepage, remap);
Jeff Layton6e462b92010-02-10 16:18:26 -05006153 list_len++; /* trailing null */
6154 list_len *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006155 } else { /* BB improve the check for buffer overruns BB */
Jeff Layton6e462b92010-02-10 16:18:26 -05006156 list_len = strnlen(searchName, PATH_MAX);
6157 list_len++; /* trailing null */
6158 strncpy(pSMB->FileName, searchName, list_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006159 }
6160
Jeff Layton6e462b92010-02-10 16:18:26 -05006161 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006162 pSMB->TotalDataCount = 0;
6163 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006164 /* BB find exact max SMB PDU from sess structure BB */
Jeff Laytone5296142010-02-10 16:18:26 -05006165 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006166 pSMB->MaxSetupCount = 0;
6167 pSMB->Reserved = 0;
6168 pSMB->Flags = 0;
6169 pSMB->Timeout = 0;
6170 pSMB->Reserved2 = 0;
6171 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00006172 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006173 pSMB->DataCount = 0;
6174 pSMB->DataOffset = 0;
6175 pSMB->SetupCount = 1;
6176 pSMB->Reserved3 = 0;
6177 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6178 byte_count = params + 1 /* pad */ ;
6179 pSMB->TotalParameterCount = cpu_to_le16(params);
6180 pSMB->ParameterCount = pSMB->TotalParameterCount;
6181 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6182 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006183 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006184 pSMB->ByteCount = cpu_to_le16(byte_count);
6185
6186 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6187 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6188 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006189 cFYI(1, "Send error in QueryAllEAs = %d", rc);
Jeff Laytonf0d38682010-02-10 16:18:26 -05006190 goto QAllEAsOut;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006191 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006192
6193
6194 /* BB also check enough total bytes returned */
6195 /* BB we need to improve the validity checking
6196 of these trans2 responses */
6197
6198 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Jeff Layton820a8032011-05-04 08:05:26 -04006199 if (rc || get_bcc(&pSMBr->hdr) < 4) {
Jeff Laytonf0d38682010-02-10 16:18:26 -05006200 rc = -EIO; /* bad smb */
6201 goto QAllEAsOut;
6202 }
6203
6204 /* check that length of list is not more than bcc */
6205 /* check that each entry does not go beyond length
6206 of list */
6207 /* check that each element of each entry does not
6208 go beyond end of list */
6209 /* validate_trans2_offsets() */
6210 /* BB check if start of smb + data_offset > &bcc+ bcc */
6211
6212 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6213 ea_response_data = (struct fealist *)
6214 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6215
Jeff Layton6e462b92010-02-10 16:18:26 -05006216 list_len = le32_to_cpu(ea_response_data->list_len);
Joe Perchesb6b38f72010-04-21 03:50:45 +00006217 cFYI(1, "ea length %d", list_len);
Jeff Layton6e462b92010-02-10 16:18:26 -05006218 if (list_len <= 8) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006219 cFYI(1, "empty EA list returned from server");
Jeff Laytonf0d38682010-02-10 16:18:26 -05006220 goto QAllEAsOut;
6221 }
6222
Jeff Layton0cd126b2010-02-10 16:18:26 -05006223 /* make sure list_len doesn't go past end of SMB */
Jeff Layton690c5222011-01-20 13:36:51 -05006224 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
Jeff Layton0cd126b2010-02-10 16:18:26 -05006225 if ((char *)ea_response_data + list_len > end_of_smb) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006226 cFYI(1, "EA list appears to go beyond SMB");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006227 rc = -EIO;
6228 goto QAllEAsOut;
6229 }
6230
Jeff Laytonf0d38682010-02-10 16:18:26 -05006231 /* account for ea list len */
Jeff Layton6e462b92010-02-10 16:18:26 -05006232 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006233 temp_fea = ea_response_data->list;
6234 temp_ptr = (char *)temp_fea;
Jeff Layton6e462b92010-02-10 16:18:26 -05006235 while (list_len > 0) {
Steve French122ca002010-02-24 21:56:48 +00006236 unsigned int name_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006237 __u16 value_len;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006238
Jeff Layton6e462b92010-02-10 16:18:26 -05006239 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006240 temp_ptr += 4;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006241 /* make sure we can read name_len and value_len */
6242 if (list_len < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006243 cFYI(1, "EA entry goes beyond length of list");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006244 rc = -EIO;
6245 goto QAllEAsOut;
6246 }
6247
6248 name_len = temp_fea->name_len;
6249 value_len = le16_to_cpu(temp_fea->value_len);
6250 list_len -= name_len + 1 + value_len;
6251 if (list_len < 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00006252 cFYI(1, "EA entry goes beyond length of list");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006253 rc = -EIO;
6254 goto QAllEAsOut;
6255 }
6256
Jeff Layton31c05192010-02-10 16:18:26 -05006257 if (ea_name) {
Jeff Layton91d065c2011-07-26 18:23:47 -04006258 if (ea_name_len == name_len &&
Jeff Laytonac423442011-10-11 06:41:32 -04006259 memcmp(ea_name, temp_ptr, name_len) == 0) {
Jeff Layton31c05192010-02-10 16:18:26 -05006260 temp_ptr += name_len + 1;
6261 rc = value_len;
6262 if (buf_size == 0)
6263 goto QAllEAsOut;
6264 if ((size_t)value_len > buf_size) {
6265 rc = -ERANGE;
6266 goto QAllEAsOut;
6267 }
6268 memcpy(EAData, temp_ptr, value_len);
6269 goto QAllEAsOut;
6270 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006271 } else {
Jeff Layton31c05192010-02-10 16:18:26 -05006272 /* account for prefix user. and trailing null */
6273 rc += (5 + 1 + name_len);
6274 if (rc < (int) buf_size) {
6275 memcpy(EAData, "user.", 5);
6276 EAData += 5;
6277 memcpy(EAData, temp_ptr, name_len);
6278 EAData += name_len;
6279 /* null terminate name */
6280 *EAData = 0;
6281 ++EAData;
6282 } else if (buf_size == 0) {
6283 /* skip copy - calc size only */
6284 } else {
6285 /* stop before overrun buffer */
6286 rc = -ERANGE;
6287 break;
6288 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006289 }
Jeff Layton0cd126b2010-02-10 16:18:26 -05006290 temp_ptr += name_len + 1 + value_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006291 temp_fea = (struct fea *)temp_ptr;
6292 }
6293
Jeff Layton31c05192010-02-10 16:18:26 -05006294 /* didn't find the named attribute */
6295 if (ea_name)
6296 rc = -ENODATA;
6297
Jeff Laytonf0d38682010-02-10 16:18:26 -05006298QAllEAsOut:
Steve French0d817bc2008-05-22 02:02:03 +00006299 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006300 if (rc == -EAGAIN)
6301 goto QAllEAsRetry;
6302
6303 return (ssize_t)rc;
6304}
6305
Linus Torvalds1da177e2005-04-16 15:20:36 -07006306int
Steve French96daf2b2011-05-27 04:34:02 +00006307CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
Steve French50c2f752007-07-13 00:33:32 +00006308 const char *ea_name, const void *ea_value,
6309 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6310 int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006311{
6312 struct smb_com_transaction2_spi_req *pSMB = NULL;
6313 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6314 struct fealist *parm_data;
6315 int name_len;
6316 int rc = 0;
6317 int bytes_returned = 0;
6318 __u16 params, param_offset, byte_count, offset, count;
6319
Joe Perchesb6b38f72010-04-21 03:50:45 +00006320 cFYI(1, "In SetEA");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006321SetEARetry:
6322 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6323 (void **) &pSMBr);
6324 if (rc)
6325 return rc;
6326
6327 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6328 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06006329 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6330 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006331 name_len++; /* trailing null */
6332 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00006333 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006334 name_len = strnlen(fileName, PATH_MAX);
6335 name_len++; /* trailing null */
6336 strncpy(pSMB->FileName, fileName, name_len);
6337 }
6338
6339 params = 6 + name_len;
6340
6341 /* done calculating parms using name_len of file name,
6342 now use name_len to calculate length of ea name
6343 we are going to create in the inode xattrs */
Steve French790fe572007-07-07 19:25:05 +00006344 if (ea_name == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006345 name_len = 0;
6346 else
Steve French50c2f752007-07-13 00:33:32 +00006347 name_len = strnlen(ea_name, 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006348
Steve Frenchdae5dbd2007-12-30 23:49:57 +00006349 count = sizeof(*parm_data) + ea_value_len + name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006350 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006351 /* BB find max SMB PDU from sess */
6352 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006353 pSMB->MaxSetupCount = 0;
6354 pSMB->Reserved = 0;
6355 pSMB->Flags = 0;
6356 pSMB->Timeout = 0;
6357 pSMB->Reserved2 = 0;
6358 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006359 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006360 offset = param_offset + params;
6361 pSMB->InformationLevel =
6362 cpu_to_le16(SMB_SET_FILE_EA);
6363
6364 parm_data =
6365 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6366 offset);
6367 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6368 pSMB->DataOffset = cpu_to_le16(offset);
6369 pSMB->SetupCount = 1;
6370 pSMB->Reserved3 = 0;
6371 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6372 byte_count = 3 /* pad */ + params + count;
6373 pSMB->DataCount = cpu_to_le16(count);
6374 parm_data->list_len = cpu_to_le32(count);
6375 parm_data->list[0].EA_flags = 0;
6376 /* we checked above that name len is less than 255 */
Alexey Dobriyan53b35312006-03-24 03:16:13 -08006377 parm_data->list[0].name_len = (__u8)name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006378 /* EA names are always ASCII */
Steve French790fe572007-07-07 19:25:05 +00006379 if (ea_name)
Steve French50c2f752007-07-13 00:33:32 +00006380 strncpy(parm_data->list[0].name, ea_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006381 parm_data->list[0].name[name_len] = 0;
6382 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6383 /* caller ensures that ea_value_len is less than 64K but
6384 we need to ensure that it fits within the smb */
6385
Steve French50c2f752007-07-13 00:33:32 +00006386 /*BB add length check to see if it would fit in
6387 negotiated SMB buffer size BB */
Steve French790fe572007-07-07 19:25:05 +00006388 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6389 if (ea_value_len)
Steve French50c2f752007-07-13 00:33:32 +00006390 memcpy(parm_data->list[0].name+name_len+1,
6391 ea_value, ea_value_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006392
6393 pSMB->TotalDataCount = pSMB->DataCount;
6394 pSMB->ParameterCount = cpu_to_le16(params);
6395 pSMB->TotalParameterCount = pSMB->ParameterCount;
6396 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006397 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006398 pSMB->ByteCount = cpu_to_le16(byte_count);
6399 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6400 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006401 if (rc)
Joe Perchesb6b38f72010-04-21 03:50:45 +00006402 cFYI(1, "SetPathInfo (EA) returned %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006403
6404 cifs_buf_release(pSMB);
6405
6406 if (rc == -EAGAIN)
6407 goto SetEARetry;
6408
6409 return rc;
6410}
Linus Torvalds1da177e2005-04-16 15:20:36 -07006411#endif
Steve French0eff0e22011-02-24 05:39:23 +00006412
6413#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6414/*
6415 * Years ago the kernel added a "dnotify" function for Samba server,
6416 * to allow network clients (such as Windows) to display updated
6417 * lists of files in directory listings automatically when
6418 * files are added by one user when another user has the
6419 * same directory open on their desktop. The Linux cifs kernel
6420 * client hooked into the kernel side of this interface for
6421 * the same reason, but ironically when the VFS moved from
6422 * "dnotify" to "inotify" it became harder to plug in Linux
6423 * network file system clients (the most obvious use case
6424 * for notify interfaces is when multiple users can update
6425 * the contents of the same directory - exactly what network
6426 * file systems can do) although the server (Samba) could
6427 * still use it. For the short term we leave the worker
6428 * function ifdeffed out (below) until inotify is fixed
6429 * in the VFS to make it easier to plug in network file
6430 * system clients. If inotify turns out to be permanently
6431 * incompatible for network fs clients, we could instead simply
6432 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6433 */
Steve French96daf2b2011-05-27 04:34:02 +00006434int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
Steve French0eff0e22011-02-24 05:39:23 +00006435 const int notify_subdirs, const __u16 netfid,
6436 __u32 filter, struct file *pfile, int multishot,
6437 const struct nls_table *nls_codepage)
6438{
6439 int rc = 0;
6440 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6441 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6442 struct dir_notify_req *dnotify_req;
6443 int bytes_returned;
6444
6445 cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
6446 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6447 (void **) &pSMBr);
6448 if (rc)
6449 return rc;
6450
6451 pSMB->TotalParameterCount = 0 ;
6452 pSMB->TotalDataCount = 0;
6453 pSMB->MaxParameterCount = cpu_to_le32(2);
Jeff Laytonc974bef2011-10-11 06:41:32 -04006454 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Steve French0eff0e22011-02-24 05:39:23 +00006455 pSMB->MaxSetupCount = 4;
6456 pSMB->Reserved = 0;
6457 pSMB->ParameterOffset = 0;
6458 pSMB->DataCount = 0;
6459 pSMB->DataOffset = 0;
6460 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6461 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6462 pSMB->ParameterCount = pSMB->TotalParameterCount;
6463 if (notify_subdirs)
6464 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6465 pSMB->Reserved2 = 0;
6466 pSMB->CompletionFilter = cpu_to_le32(filter);
6467 pSMB->Fid = netfid; /* file handle always le */
6468 pSMB->ByteCount = 0;
6469
6470 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6471 (struct smb_hdr *)pSMBr, &bytes_returned,
6472 CIFS_ASYNC_OP);
6473 if (rc) {
6474 cFYI(1, "Error in Notify = %d", rc);
6475 } else {
6476 /* Add file to outstanding requests */
6477 /* BB change to kmem cache alloc */
6478 dnotify_req = kmalloc(
6479 sizeof(struct dir_notify_req),
6480 GFP_KERNEL);
6481 if (dnotify_req) {
6482 dnotify_req->Pid = pSMB->hdr.Pid;
6483 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6484 dnotify_req->Mid = pSMB->hdr.Mid;
6485 dnotify_req->Tid = pSMB->hdr.Tid;
6486 dnotify_req->Uid = pSMB->hdr.Uid;
6487 dnotify_req->netfid = netfid;
6488 dnotify_req->pfile = pfile;
6489 dnotify_req->filter = filter;
6490 dnotify_req->multishot = multishot;
6491 spin_lock(&GlobalMid_Lock);
6492 list_add_tail(&dnotify_req->lhead,
6493 &GlobalDnotifyReqList);
6494 spin_unlock(&GlobalMid_Lock);
6495 } else
6496 rc = -ENOMEM;
6497 }
6498 cifs_buf_release(pSMB);
6499 return rc;
6500}
6501#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */