blob: 6ce4e0954b986ac1dd40bfb6dd9a8a851bef68d1 [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
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +040089/*
90 * Mark as invalid, all open files on tree connections since they
91 * were closed when session to server was lost.
92 */
93void
94cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
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
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400100 /* 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);
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400102 list_for_each_safe(tmp, tmp1, &tcon->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);
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400108 /*
109 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
110 * to this tcon.
111 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
Jeff Layton9162ab22009-09-03 12:07:17 -0400114/* reconnect the socket, tcon, and smb session if needed */
115static int
Steve French96daf2b2011-05-27 04:34:02 +0000116cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
Jeff Layton9162ab22009-09-03 12:07:17 -0400117{
Jeff Laytonc4a55342011-07-28 12:40:36 -0400118 int rc;
Steve French96daf2b2011-05-27 04:34:02 +0000119 struct cifs_ses *ses;
Jeff Layton9162ab22009-09-03 12:07:17 -0400120 struct TCP_Server_Info *server;
121 struct nls_table *nls_codepage;
122
123 /*
124 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
125 * tcp and smb session status done differently for those three - in the
126 * calling routine
127 */
128 if (!tcon)
129 return 0;
130
131 ses = tcon->ses;
132 server = ses->server;
133
134 /*
135 * only tree disconnect, open, and write, (and ulogoff which does not
136 * have tcon) are allowed as we start force umount
137 */
138 if (tcon->tidStatus == CifsExiting) {
139 if (smb_command != SMB_COM_WRITE_ANDX &&
140 smb_command != SMB_COM_OPEN_ANDX &&
141 smb_command != SMB_COM_TREE_DISCONNECT) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500142 cifs_dbg(FYI, "can not send cmd %d while umounting\n",
143 smb_command);
Jeff Layton9162ab22009-09-03 12:07:17 -0400144 return -ENODEV;
145 }
146 }
147
Jeff Layton9162ab22009-09-03 12:07:17 -0400148 /*
149 * Give demultiplex thread up to 10 seconds to reconnect, should be
150 * greater than cifs socket timeout which is 7 seconds
151 */
152 while (server->tcpStatus == CifsNeedReconnect) {
153 wait_event_interruptible_timeout(server->response_q,
Steve Frenchfd88ce92011-04-12 01:01:14 +0000154 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
Jeff Layton9162ab22009-09-03 12:07:17 -0400155
Steve Frenchfd88ce92011-04-12 01:01:14 +0000156 /* are we still trying to reconnect? */
Jeff Layton9162ab22009-09-03 12:07:17 -0400157 if (server->tcpStatus != CifsNeedReconnect)
158 break;
159
160 /*
161 * on "soft" mounts we wait once. Hard mounts keep
162 * retrying until process is killed or server comes
163 * back on-line
164 */
Jeff Laytond4025392011-02-07 08:54:35 -0500165 if (!tcon->retry) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500166 cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
Jeff Layton9162ab22009-09-03 12:07:17 -0400167 return -EHOSTDOWN;
168 }
169 }
170
171 if (!ses->need_reconnect && !tcon->need_reconnect)
172 return 0;
173
174 nls_codepage = load_nls_default();
175
176 /*
177 * need to prevent multiple threads trying to simultaneously
178 * reconnect the same SMB session
179 */
Steve Frenchd7b619c2010-02-25 05:36:46 +0000180 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -0400181 rc = cifs_negotiate_protocol(0, ses);
182 if (rc == 0 && ses->need_reconnect)
Jeff Layton9162ab22009-09-03 12:07:17 -0400183 rc = cifs_setup_session(0, ses, nls_codepage);
184
185 /* do we need to reconnect tcon? */
186 if (rc || !tcon->need_reconnect) {
Steve Frenchd7b619c2010-02-25 05:36:46 +0000187 mutex_unlock(&ses->session_mutex);
Jeff Layton9162ab22009-09-03 12:07:17 -0400188 goto out;
189 }
190
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400191 cifs_mark_open_files_invalid(tcon);
Jeff Layton9162ab22009-09-03 12:07:17 -0400192 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
Steve Frenchd7b619c2010-02-25 05:36:46 +0000193 mutex_unlock(&ses->session_mutex);
Joe Perchesf96637b2013-05-04 22:12:25 -0500194 cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc);
Jeff Layton9162ab22009-09-03 12:07:17 -0400195
196 if (rc)
197 goto out;
198
199 /*
200 * FIXME: check if wsize needs updated due to negotiated smb buffer
201 * size shrinking
202 */
203 atomic_inc(&tconInfoReconnectCount);
204
205 /* tell server Unix caps we support */
206 if (ses->capabilities & CAP_UNIX)
207 reset_cifs_unix_caps(0, tcon, NULL, NULL);
208
209 /*
210 * Removed call to reopen open files here. It is safer (and faster) to
211 * reopen files one at a time as needed in read and write.
212 *
213 * FIXME: what about file locks? don't we need to reclaim them ASAP?
214 */
215
216out:
217 /*
218 * Check if handle based operation so we know whether we can continue
219 * or not without returning to caller to reset file handle
220 */
221 switch (smb_command) {
222 case SMB_COM_READ_ANDX:
223 case SMB_COM_WRITE_ANDX:
224 case SMB_COM_CLOSE:
225 case SMB_COM_FIND_CLOSE2:
226 case SMB_COM_LOCKING_ANDX:
227 rc = -EAGAIN;
228 }
229
230 unload_nls(nls_codepage);
231 return rc;
232}
233
Steve Frenchad7a2922008-02-07 23:25:02 +0000234/* Allocate and return pointer to an SMB request buffer, and set basic
235 SMB information in the SMB header. If the return code is zero, this
236 function must have filled in request_buf pointer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237static int
Steve French96daf2b2011-05-27 04:34:02 +0000238small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +0000239 void **request_buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Jeff Laytonf5695992010-09-29 15:27:08 -0400241 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Jeff Layton9162ab22009-09-03 12:07:17 -0400243 rc = cifs_reconnect_tcon(tcon, smb_command);
Steve French790fe572007-07-07 19:25:05 +0000244 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 return rc;
246
247 *request_buf = cifs_small_buf_get();
248 if (*request_buf == NULL) {
249 /* BB should we add a retry in here if not a writepage? */
250 return -ENOMEM;
251 }
252
Steve French63135e02007-07-17 17:34:02 +0000253 header_assemble((struct smb_hdr *) *request_buf, smb_command,
Steve Frenchc18c8422007-07-18 23:21:09 +0000254 tcon, wct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Steve French790fe572007-07-07 19:25:05 +0000256 if (tcon != NULL)
257 cifs_stats_inc(&tcon->num_smbs_sent);
Steve Frencha4544342005-08-24 13:59:35 -0700258
Jeff Laytonf5695992010-09-29 15:27:08 -0400259 return 0;
Steve French5815449d2006-02-14 01:36:20 +0000260}
261
Steve French12b3b8f2006-02-09 21:12:47 +0000262int
Steve French50c2f752007-07-13 00:33:32 +0000263small_smb_init_no_tc(const int smb_command, const int wct,
Steve French96daf2b2011-05-27 04:34:02 +0000264 struct cifs_ses *ses, void **request_buf)
Steve French12b3b8f2006-02-09 21:12:47 +0000265{
266 int rc;
Steve French50c2f752007-07-13 00:33:32 +0000267 struct smb_hdr *buffer;
Steve French12b3b8f2006-02-09 21:12:47 +0000268
Steve French5815449d2006-02-14 01:36:20 +0000269 rc = small_smb_init(smb_command, wct, NULL, request_buf);
Steve French790fe572007-07-07 19:25:05 +0000270 if (rc)
Steve French12b3b8f2006-02-09 21:12:47 +0000271 return rc;
272
Steve French04fdabe2006-02-10 05:52:50 +0000273 buffer = (struct smb_hdr *)*request_buf;
Pavel Shilovsky88257362012-05-23 14:01:59 +0400274 buffer->Mid = get_next_mid(ses->server);
Steve French12b3b8f2006-02-09 21:12:47 +0000275 if (ses->capabilities & CAP_UNICODE)
276 buffer->Flags2 |= SMBFLG2_UNICODE;
Steve French04fdabe2006-02-10 05:52:50 +0000277 if (ses->capabilities & CAP_STATUS32)
Steve French12b3b8f2006-02-09 21:12:47 +0000278 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
279
280 /* uid, tid can stay at zero as set in header assemble */
281
Steve French50c2f752007-07-13 00:33:32 +0000282 /* BB add support for turning on the signing when
Steve French12b3b8f2006-02-09 21:12:47 +0000283 this function is used after 1st of session setup requests */
284
285 return rc;
286}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288/* If the return code is zero, this function must fill in request_buf pointer */
289static int
Steve French96daf2b2011-05-27 04:34:02 +0000290__smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400291 void **request_buf, void **response_buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 *request_buf = cifs_buf_get();
294 if (*request_buf == NULL) {
295 /* BB should we add a retry in here if not a writepage? */
296 return -ENOMEM;
297 }
298 /* Although the original thought was we needed the response buf for */
299 /* potential retries of smb operations it turns out we can determine */
300 /* from the mid flags when the request buffer can be resent without */
301 /* having to use a second distinct buffer for the response */
Steve French790fe572007-07-07 19:25:05 +0000302 if (response_buf)
Steve French50c2f752007-07-13 00:33:32 +0000303 *response_buf = *request_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +0000306 wct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Steve French790fe572007-07-07 19:25:05 +0000308 if (tcon != NULL)
309 cifs_stats_inc(&tcon->num_smbs_sent);
Steve Frencha4544342005-08-24 13:59:35 -0700310
Jeff Laytonf5695992010-09-29 15:27:08 -0400311 return 0;
312}
313
314/* If the return code is zero, this function must fill in request_buf pointer */
315static int
Steve French96daf2b2011-05-27 04:34:02 +0000316smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400317 void **request_buf, void **response_buf)
318{
319 int rc;
320
321 rc = cifs_reconnect_tcon(tcon, smb_command);
322 if (rc)
323 return rc;
324
325 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
326}
327
328static int
Steve French96daf2b2011-05-27 04:34:02 +0000329smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
Jeff Laytonf5695992010-09-29 15:27:08 -0400330 void **request_buf, void **response_buf)
331{
332 if (tcon->ses->need_reconnect || tcon->need_reconnect)
333 return -EHOSTDOWN;
334
335 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
Steve French50c2f752007-07-13 00:33:32 +0000338static int validate_t2(struct smb_t2_rsp *pSMB)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
Jeff Layton12df83c2011-01-20 13:36:51 -0500340 unsigned int total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Jeff Layton12df83c2011-01-20 13:36:51 -0500342 /* check for plausible wct */
343 if (pSMB->hdr.WordCount < 10)
344 goto vt2_err;
345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 /* check for parm and data offset going beyond end of smb */
Jeff Layton12df83c2011-01-20 13:36:51 -0500347 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
348 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
349 goto vt2_err;
350
Jeff Layton12df83c2011-01-20 13:36:51 -0500351 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
352 if (total_size >= 512)
353 goto vt2_err;
354
Jeff Laytonfd5707e2011-03-31 17:22:07 -0400355 /* check that bcc is at least as big as parms + data, and that it is
356 * less than negotiated smb buffer
357 */
Jeff Layton12df83c2011-01-20 13:36:51 -0500358 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
359 if (total_size > get_bcc(&pSMB->hdr) ||
360 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
361 goto vt2_err;
362
363 return 0;
364vt2_err:
Steve French50c2f752007-07-13 00:33:32 +0000365 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 sizeof(struct smb_t2_rsp) + 16);
Jeff Layton12df83c2011-01-20 13:36:51 -0500367 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368}
Jeff Layton690c5222011-01-20 13:36:51 -0500369
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400370static int
Jeff Layton3f618222013-06-12 19:52:14 -0500371decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400372{
373 int rc = 0;
374 u16 count;
375 char *guid = pSMBr->u.extended_response.GUID;
Jeff Layton3f618222013-06-12 19:52:14 -0500376 struct TCP_Server_Info *server = ses->server;
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400377
378 count = get_bcc(&pSMBr->hdr);
379 if (count < SMB1_CLIENT_GUID_SIZE)
380 return -EIO;
381
382 spin_lock(&cifs_tcp_ses_lock);
383 if (server->srv_count > 1) {
384 spin_unlock(&cifs_tcp_ses_lock);
385 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
386 cifs_dbg(FYI, "server UID changed\n");
387 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
388 }
389 } else {
390 spin_unlock(&cifs_tcp_ses_lock);
391 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
392 }
393
394 if (count == SMB1_CLIENT_GUID_SIZE) {
Jeff Layton3f618222013-06-12 19:52:14 -0500395 server->sec_ntlmssp = true;
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400396 } else {
397 count -= SMB1_CLIENT_GUID_SIZE;
398 rc = decode_negTokenInit(
399 pSMBr->u.extended_response.SecurityBlob, count, server);
400 if (rc != 1)
401 return -EINVAL;
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400402 }
403
404 return 0;
405}
406
Jeff Layton9ddec562013-05-26 07:00:58 -0400407int
Jeff Layton38d77c52013-05-26 07:01:00 -0400408cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
Jeff Layton9ddec562013-05-26 07:00:58 -0400409{
Jeff Layton50285882013-06-27 12:45:00 -0400410 bool srv_sign_required = server->sec_mode & server->vals->signing_required;
411 bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
Jeff Layton38d77c52013-05-26 07:01:00 -0400412 bool mnt_sign_enabled = global_secflags & CIFSSEC_MAY_SIGN;
413
414 /*
415 * Is signing required by mnt options? If not then check
416 * global_secflags to see if it is there.
417 */
418 if (!mnt_sign_required)
419 mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
420 CIFSSEC_MUST_SIGN);
421
422 /*
423 * If signing is required then it's automatically enabled too,
424 * otherwise, check to see if the secflags allow it.
425 */
426 mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
427 (global_secflags & CIFSSEC_MAY_SIGN);
428
429 /* If server requires signing, does client allow it? */
430 if (srv_sign_required) {
431 if (!mnt_sign_enabled) {
432 cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!");
433 return -ENOTSUPP;
Jeff Layton9ddec562013-05-26 07:00:58 -0400434 }
Jeff Layton38d77c52013-05-26 07:01:00 -0400435 server->sign = true;
436 }
437
438 /* If client requires signing, does server allow it? */
439 if (mnt_sign_required) {
440 if (!srv_sign_enabled) {
441 cifs_dbg(VFS, "Server does not support signing!");
442 return -ENOTSUPP;
443 }
444 server->sign = true;
Jeff Layton9ddec562013-05-26 07:00:58 -0400445 }
446
447 return 0;
448}
449
Jeff Layton2190eca2013-05-26 07:00:57 -0400450#ifdef CONFIG_CIFS_WEAK_PW_HASH
451static int
Jeff Layton3f618222013-06-12 19:52:14 -0500452decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
Jeff Layton2190eca2013-05-26 07:00:57 -0400453{
454 __s16 tmp;
455 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
456
457 if (server->dialect != LANMAN_PROT && server->dialect != LANMAN2_PROT)
458 return -EOPNOTSUPP;
459
Jeff Layton2190eca2013-05-26 07:00:57 -0400460 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
461 server->maxReq = min_t(unsigned int,
462 le16_to_cpu(rsp->MaxMpxCount),
463 cifs_max_pending);
464 set_credits(server, server->maxReq);
465 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
Jeff Layton2190eca2013-05-26 07:00:57 -0400466 /* even though we do not use raw we might as well set this
467 accurately, in case we ever find a need for it */
468 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
469 server->max_rw = 0xFF00;
470 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
471 } else {
472 server->max_rw = 0;/* do not need to use raw anyway */
473 server->capabilities = CAP_MPX_MODE;
474 }
475 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
476 if (tmp == -1) {
477 /* OS/2 often does not set timezone therefore
478 * we must use server time to calc time zone.
479 * Could deviate slightly from the right zone.
480 * Smallest defined timezone difference is 15 minutes
481 * (i.e. Nepal). Rounding up/down is done to match
482 * this requirement.
483 */
484 int val, seconds, remain, result;
485 struct timespec ts, utc;
486 utc = CURRENT_TIME;
487 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
488 rsp->SrvTime.Time, 0);
489 cifs_dbg(FYI, "SrvTime %d sec since 1970 (utc: %d) diff: %d\n",
490 (int)ts.tv_sec, (int)utc.tv_sec,
491 (int)(utc.tv_sec - ts.tv_sec));
492 val = (int)(utc.tv_sec - ts.tv_sec);
493 seconds = abs(val);
494 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
495 remain = seconds % MIN_TZ_ADJ;
496 if (remain >= (MIN_TZ_ADJ / 2))
497 result += MIN_TZ_ADJ;
498 if (val < 0)
499 result = -result;
500 server->timeAdj = result;
501 } else {
502 server->timeAdj = (int)tmp;
503 server->timeAdj *= 60; /* also in seconds */
504 }
505 cifs_dbg(FYI, "server->timeAdj: %d seconds\n", server->timeAdj);
506
507
508 /* BB get server time for time conversions and add
509 code to use it and timezone since this is not UTC */
510
511 if (rsp->EncryptionKeyLength ==
512 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
513 memcpy(server->cryptkey, rsp->EncryptionKey,
514 CIFS_CRYPTO_KEY_SIZE);
515 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
516 return -EIO; /* need cryptkey unless plain text */
517 }
518
519 cifs_dbg(FYI, "LANMAN negotiated\n");
520 return 0;
521}
522#else
523static inline int
Jeff Layton3f618222013-06-12 19:52:14 -0500524decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
Jeff Layton2190eca2013-05-26 07:00:57 -0400525{
526 cifs_dbg(VFS, "mount failed, cifs module not built with CIFS_WEAK_PW_HASH support\n");
527 return -EOPNOTSUPP;
528}
529#endif
530
Jeff Layton91934002013-05-26 07:00:58 -0400531static bool
Jeff Layton3f618222013-06-12 19:52:14 -0500532should_set_ext_sec_flag(enum securityEnum sectype)
Jeff Layton91934002013-05-26 07:00:58 -0400533{
Jeff Layton3f618222013-06-12 19:52:14 -0500534 switch (sectype) {
535 case RawNTLMSSP:
536 case Kerberos:
Jeff Layton91934002013-05-26 07:00:58 -0400537 return true;
Jeff Layton3f618222013-06-12 19:52:14 -0500538 case Unspecified:
539 if (global_secflags &
540 (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP))
541 return true;
542 /* Fallthrough */
543 default:
544 return false;
545 }
Jeff Layton91934002013-05-26 07:00:58 -0400546}
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548int
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400549CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
551 NEGOTIATE_REQ *pSMB;
552 NEGOTIATE_RSP *pSMBr;
553 int rc = 0;
554 int bytes_returned;
Steve French39798772006-05-31 22:40:51 +0000555 int i;
Jeff Layton3534b852013-05-24 07:41:01 -0400556 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 u16 count;
558
Jeff Layton3534b852013-05-24 07:41:01 -0400559 if (!server) {
560 WARN(1, "%s: server is NULL!\n", __func__);
561 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 }
Jeff Layton3534b852013-05-24 07:41:01 -0400563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
565 (void **) &pSMB, (void **) &pSMBr);
566 if (rc)
567 return rc;
Steve French750d1152006-06-27 06:28:30 +0000568
Pavel Shilovsky88257362012-05-23 14:01:59 +0400569 pSMB->hdr.Mid = get_next_mid(server);
Yehuda Sadeh Weinraub100c1dd2007-06-05 21:31:16 +0000570 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
Steve Frencha0136892007-10-04 20:05:09 +0000571
Jeff Layton3f618222013-06-12 19:52:14 -0500572 if (should_set_ext_sec_flag(ses->sectype)) {
Jeff Layton91934002013-05-26 07:00:58 -0400573 cifs_dbg(FYI, "Requesting extended security.");
Steve Frenchac683922009-05-06 04:16:04 +0000574 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
575 }
Steve French50c2f752007-07-13 00:33:32 +0000576
Steve French39798772006-05-31 22:40:51 +0000577 count = 0;
Steve French50c2f752007-07-13 00:33:32 +0000578 for (i = 0; i < CIFS_NUM_PROT; i++) {
Steve French39798772006-05-31 22:40:51 +0000579 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
580 count += strlen(protocols[i].name) + 1;
581 /* null at end of source and target buffers anyway */
582 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000583 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 pSMB->ByteCount = cpu_to_le16(count);
585
586 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
587 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French50c2f752007-07-13 00:33:32 +0000588 if (rc != 0)
Steve French254e55e2006-06-04 05:53:15 +0000589 goto neg_err_exit;
590
Jeff Layton9bf67e52010-04-24 07:57:46 -0400591 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
Joe Perchesf96637b2013-05-04 22:12:25 -0500592 cifs_dbg(FYI, "Dialect: %d\n", server->dialect);
Steve French254e55e2006-06-04 05:53:15 +0000593 /* Check wct = 1 error case */
Jeff Layton9bf67e52010-04-24 07:57:46 -0400594 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
Steve French254e55e2006-06-04 05:53:15 +0000595 /* core returns wct = 1, but we do not ask for core - otherwise
Steve French50c2f752007-07-13 00:33:32 +0000596 small wct just comes when dialect index is -1 indicating we
Steve French254e55e2006-06-04 05:53:15 +0000597 could not negotiate a common dialect */
598 rc = -EOPNOTSUPP;
599 goto neg_err_exit;
Steve French790fe572007-07-07 19:25:05 +0000600 } else if (pSMBr->hdr.WordCount == 13) {
Jeff Laytone598d1d82013-05-26 07:00:59 -0400601 server->negflavor = CIFS_NEGFLAVOR_LANMAN;
Jeff Layton3f618222013-06-12 19:52:14 -0500602 rc = decode_lanman_negprot_rsp(server, pSMBr);
Jeff Layton9ddec562013-05-26 07:00:58 -0400603 goto signing_check;
Steve French790fe572007-07-07 19:25:05 +0000604 } else if (pSMBr->hdr.WordCount != 17) {
Steve French254e55e2006-06-04 05:53:15 +0000605 /* unknown wct */
606 rc = -EOPNOTSUPP;
607 goto neg_err_exit;
608 }
Jeff Layton2190eca2013-05-26 07:00:57 -0400609 /* else wct == 17, NTLM or better */
610
Steve French96daf2b2011-05-27 04:34:02 +0000611 server->sec_mode = pSMBr->SecurityMode;
612 if ((server->sec_mode & SECMODE_USER) == 0)
Joe Perchesf96637b2013-05-04 22:12:25 -0500613 cifs_dbg(FYI, "share mode security\n");
Steve French39798772006-05-31 22:40:51 +0000614
Steve French254e55e2006-06-04 05:53:15 +0000615 /* one byte, so no need to convert this or EncryptionKeyLen from
616 little endian */
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300617 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
618 cifs_max_pending);
Pavel Shilovsky45275782012-05-17 17:53:29 +0400619 set_credits(server, server->maxReq);
Steve French254e55e2006-06-04 05:53:15 +0000620 /* probably no need to store and check maxvcs */
Jeff Laytonc974bef2011-10-11 06:41:32 -0400621 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
Steve Frencheca6acf2009-02-20 05:43:09 +0000622 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
Joe Perchesf96637b2013-05-04 22:12:25 -0500623 cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
Steve French254e55e2006-06-04 05:53:15 +0000624 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
Steve Frenchb815f1e52006-10-02 05:53:29 +0000625 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
626 server->timeAdj *= 60;
Jeff Layton31d9e2b2013-05-26 07:00:57 -0400627
Jeff Laytone598d1d82013-05-26 07:00:59 -0400628 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
629 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -0500630 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
Steve French254e55e2006-06-04 05:53:15 +0000631 CIFS_CRYPTO_KEY_SIZE);
Jeff Laytone598d1d82013-05-26 07:00:59 -0400632 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
Steve French07cc6cf2011-05-27 04:12:29 +0000633 server->capabilities & CAP_EXTENDED_SECURITY) &&
Jeff Laytone598d1d82013-05-26 07:00:59 -0400634 (pSMBr->EncryptionKeyLength == 0)) {
635 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
Jeff Layton3f618222013-06-12 19:52:14 -0500636 rc = decode_ext_sec_blob(ses, pSMBr);
Jeff Laytone598d1d82013-05-26 07:00:59 -0400637 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
Steve French07cc6cf2011-05-27 04:12:29 +0000638 rc = -EIO; /* no crypt key only if plain text pwd */
Jeff Laytone598d1d82013-05-26 07:00:59 -0400639 } else {
640 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
Steve French254e55e2006-06-04 05:53:15 +0000641 server->capabilities &= ~CAP_EXTENDED_SECURITY;
Jeff Laytone598d1d82013-05-26 07:00:59 -0400642 }
Steve French254e55e2006-06-04 05:53:15 +0000643
644signing_check:
Jeff Layton9ddec562013-05-26 07:00:58 -0400645 if (!rc)
Jeff Layton38d77c52013-05-26 07:01:00 -0400646 rc = cifs_enable_signing(server, ses->sign);
Steve French50c2f752007-07-13 00:33:32 +0000647neg_err_exit:
Steve French4a6d87f2005-08-13 08:15:54 -0700648 cifs_buf_release(pSMB);
Steve French254e55e2006-06-04 05:53:15 +0000649
Joe Perchesf96637b2013-05-04 22:12:25 -0500650 cifs_dbg(FYI, "negprot rc %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 return rc;
652}
653
654int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +0400655CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656{
657 struct smb_hdr *smb_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Joe Perchesf96637b2013-05-04 22:12:25 -0500660 cifs_dbg(FYI, "In tree disconnect\n");
Jeff Laytonf1987b42008-11-15 11:12:47 -0500661
662 /* BB: do we need to check this? These should never be NULL. */
663 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
664 return -EIO;
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 /*
Jeff Laytonf1987b42008-11-15 11:12:47 -0500667 * No need to return error on this operation if tid invalidated and
668 * closed on server already e.g. due to tcp session crashing. Also,
669 * the tcon is no longer on the list, so no need to take lock before
670 * checking this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 */
Steve French268875b2009-06-25 00:29:21 +0000672 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
Steve French50c2f752007-07-13 00:33:32 +0000673 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
Steve French50c2f752007-07-13 00:33:32 +0000675 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
Steve French09d1db52005-04-28 22:41:08 -0700676 (void **)&smb_buffer);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500677 if (rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 return rc;
Steve French133672e2007-11-13 22:41:37 +0000679
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400680 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500682 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Steve French50c2f752007-07-13 00:33:32 +0000684 /* No need to return error on this operation if tid invalidated and
Jeff Laytonf1987b42008-11-15 11:12:47 -0500685 closed on server already e.g. due to tcp session crashing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 if (rc == -EAGAIN)
687 rc = 0;
688
689 return rc;
690}
691
Jeff Layton766fdbb2011-01-11 07:24:21 -0500692/*
693 * This is a no-op for now. We're not really interested in the reply, but
694 * rather in the fact that the server sent one and that server->lstrp
695 * gets updated.
696 *
697 * FIXME: maybe we should consider checking that the reply matches request?
698 */
699static void
700cifs_echo_callback(struct mid_q_entry *mid)
701{
702 struct TCP_Server_Info *server = mid->callback_data;
703
704 DeleteMidQEntry(mid);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400705 add_credits(server, 1, CIFS_ECHO_OP);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500706}
707
708int
709CIFSSMBEcho(struct TCP_Server_Info *server)
710{
711 ECHO_REQ *smb;
712 int rc = 0;
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400713 struct kvec iov;
Jeff Laytonfec344e2012-09-18 16:20:35 -0700714 struct smb_rqst rqst = { .rq_iov = &iov,
715 .rq_nvec = 1 };
Jeff Layton766fdbb2011-01-11 07:24:21 -0500716
Joe Perchesf96637b2013-05-04 22:12:25 -0500717 cifs_dbg(FYI, "In echo request\n");
Jeff Layton766fdbb2011-01-11 07:24:21 -0500718
719 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
720 if (rc)
721 return rc;
722
723 /* set up echo request */
Steve French5443d132011-03-13 05:08:25 +0000724 smb->hdr.Tid = 0xffff;
Jeff Layton99d86c82011-01-20 21:19:25 -0500725 smb->hdr.WordCount = 1;
726 put_unaligned_le16(1, &smb->EchoCount);
Jeff Layton820a8032011-05-04 08:05:26 -0400727 put_bcc(1, &smb->hdr);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500728 smb->Data[0] = 'a';
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000729 inc_rfc1001_len(smb, 3);
Jeff Laytonfcc31cb2011-05-19 16:22:53 -0400730 iov.iov_base = smb;
731 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
Jeff Layton766fdbb2011-01-11 07:24:21 -0500732
Jeff Laytonfec344e2012-09-18 16:20:35 -0700733 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback,
Pavel Shilovskya891f0f2012-05-23 16:14:34 +0400734 server, CIFS_ASYNC_OP | CIFS_ECHO_OP);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500735 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500736 cifs_dbg(FYI, "Echo request failed: %d\n", rc);
Jeff Layton766fdbb2011-01-11 07:24:21 -0500737
738 cifs_small_buf_release(smb);
739
740 return rc;
741}
742
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743int
Pavel Shilovsky58c45c52012-05-25 10:54:49 +0400744CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 LOGOFF_ANDX_REQ *pSMB;
747 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Joe Perchesf96637b2013-05-04 22:12:25 -0500749 cifs_dbg(FYI, "In SMBLogoff for session disconnect\n");
Jeff Layton14fbf502008-11-14 13:53:46 -0500750
751 /*
752 * BB: do we need to check validity of ses and server? They should
753 * always be valid since we have an active reference. If not, that
754 * should probably be a BUG()
755 */
756 if (!ses || !ses->server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return -EIO;
758
Steve Frenchd7b619c2010-02-25 05:36:46 +0000759 mutex_lock(&ses->session_mutex);
Steve French3b795212008-11-13 19:45:32 +0000760 if (ses->need_reconnect)
761 goto session_already_dead; /* no need to send SMBlogoff if uid
762 already closed due to reconnect */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
764 if (rc) {
Steve Frenchd7b619c2010-02-25 05:36:46 +0000765 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 return rc;
767 }
768
Pavel Shilovsky88257362012-05-23 14:01:59 +0400769 pSMB->hdr.Mid = get_next_mid(ses->server);
Steve French1982c342005-08-17 12:38:22 -0700770
Jeff Layton38d77c52013-05-26 07:01:00 -0400771 if (ses->server->sign)
772 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 pSMB->hdr.Uid = ses->Suid;
775
776 pSMB->AndXCommand = 0xFF;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -0400777 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
Steve French3b795212008-11-13 19:45:32 +0000778session_already_dead:
Steve Frenchd7b619c2010-02-25 05:36:46 +0000779 mutex_unlock(&ses->session_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
781 /* if session dead then we do not need to do ulogoff,
Steve French50c2f752007-07-13 00:33:32 +0000782 since server closed smb session, no sense reporting
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 error */
784 if (rc == -EAGAIN)
785 rc = 0;
786 return rc;
787}
788
789int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400790CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
791 const char *fileName, __u16 type,
792 const struct nls_table *nls_codepage, int remap)
Steve French2d785a52007-07-15 01:48:57 +0000793{
794 TRANSACTION2_SPI_REQ *pSMB = NULL;
795 TRANSACTION2_SPI_RSP *pSMBr = NULL;
796 struct unlink_psx_rq *pRqD;
797 int name_len;
798 int rc = 0;
799 int bytes_returned = 0;
800 __u16 params, param_offset, offset, byte_count;
801
Joe Perchesf96637b2013-05-04 22:12:25 -0500802 cifs_dbg(FYI, "In POSIX delete\n");
Steve French2d785a52007-07-15 01:48:57 +0000803PsxDelete:
804 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
805 (void **) &pSMBr);
806 if (rc)
807 return rc;
808
809 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
810 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -0600811 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
812 PATH_MAX, nls_codepage, remap);
Steve French2d785a52007-07-15 01:48:57 +0000813 name_len++; /* trailing null */
814 name_len *= 2;
815 } else { /* BB add path length overrun check */
816 name_len = strnlen(fileName, PATH_MAX);
817 name_len++; /* trailing null */
818 strncpy(pSMB->FileName, fileName, name_len);
819 }
820
821 params = 6 + name_len;
822 pSMB->MaxParameterCount = cpu_to_le16(2);
823 pSMB->MaxDataCount = 0; /* BB double check this with jra */
824 pSMB->MaxSetupCount = 0;
825 pSMB->Reserved = 0;
826 pSMB->Flags = 0;
827 pSMB->Timeout = 0;
828 pSMB->Reserved2 = 0;
829 param_offset = offsetof(struct smb_com_transaction2_spi_req,
830 InformationLevel) - 4;
831 offset = param_offset + params;
832
833 /* Setup pointer to Request Data (inode type) */
834 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
835 pRqD->type = cpu_to_le16(type);
836 pSMB->ParameterOffset = cpu_to_le16(param_offset);
837 pSMB->DataOffset = cpu_to_le16(offset);
838 pSMB->SetupCount = 1;
839 pSMB->Reserved3 = 0;
840 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
841 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
842
843 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
844 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
845 pSMB->ParameterCount = cpu_to_le16(params);
846 pSMB->TotalParameterCount = pSMB->ParameterCount;
847 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
848 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000849 inc_rfc1001_len(pSMB, byte_count);
Steve French2d785a52007-07-15 01:48:57 +0000850 pSMB->ByteCount = cpu_to_le16(byte_count);
851 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
852 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +0000853 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500854 cifs_dbg(FYI, "Posix delete returned %d\n", rc);
Steve French2d785a52007-07-15 01:48:57 +0000855 cifs_buf_release(pSMB);
856
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400857 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
Steve French2d785a52007-07-15 01:48:57 +0000858
859 if (rc == -EAGAIN)
860 goto PsxDelete;
861
862 return rc;
863}
864
865int
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700866CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
867 struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868{
869 DELETE_FILE_REQ *pSMB = NULL;
870 DELETE_FILE_RSP *pSMBr = NULL;
871 int rc = 0;
872 int bytes_returned;
873 int name_len;
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700874 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
876DelFileRetry:
877 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
878 (void **) &pSMBr);
879 if (rc)
880 return rc;
881
882 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700883 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
884 PATH_MAX, cifs_sb->local_nls,
885 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 name_len++; /* trailing null */
887 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700888 } else { /* BB improve check for buffer overruns BB */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700889 name_len = strnlen(name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 name_len++; /* trailing null */
Pavel Shilovskyed6875e2012-09-18 16:20:25 -0700891 strncpy(pSMB->fileName, name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 }
893 pSMB->SearchAttributes =
894 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
895 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000896 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 pSMB->ByteCount = cpu_to_le16(name_len + 1);
898 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
899 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400900 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
Steve Frenchad7a2922008-02-07 23:25:02 +0000901 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500902 cifs_dbg(FYI, "Error in RMFile = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904 cifs_buf_release(pSMB);
905 if (rc == -EAGAIN)
906 goto DelFileRetry;
907
908 return rc;
909}
910
911int
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400912CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
913 struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
915 DELETE_DIRECTORY_REQ *pSMB = NULL;
916 DELETE_DIRECTORY_RSP *pSMBr = NULL;
917 int rc = 0;
918 int bytes_returned;
919 int name_len;
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400920 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Joe Perchesf96637b2013-05-04 22:12:25 -0500922 cifs_dbg(FYI, "In CIFSSMBRmDir\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923RmDirRetry:
924 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
925 (void **) &pSMBr);
926 if (rc)
927 return rc;
928
929 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400930 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
931 PATH_MAX, cifs_sb->local_nls,
932 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 name_len++; /* trailing null */
934 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700935 } else { /* BB improve check for buffer overruns BB */
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400936 name_len = strnlen(name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 name_len++; /* trailing null */
Pavel Shilovskyf958ca52012-07-10 16:14:18 +0400938 strncpy(pSMB->DirName, name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 }
940
941 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000942 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 pSMB->ByteCount = cpu_to_le16(name_len + 1);
944 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
945 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400946 cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +0000947 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500948 cifs_dbg(FYI, "Error in RMDir = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 cifs_buf_release(pSMB);
951 if (rc == -EAGAIN)
952 goto RmDirRetry;
953 return rc;
954}
955
956int
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300957CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
958 struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959{
960 int rc = 0;
961 CREATE_DIRECTORY_REQ *pSMB = NULL;
962 CREATE_DIRECTORY_RSP *pSMBr = NULL;
963 int bytes_returned;
964 int name_len;
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300965 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Joe Perchesf96637b2013-05-04 22:12:25 -0500967 cifs_dbg(FYI, "In CIFSSMBMkDir\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968MkDirRetry:
969 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
970 (void **) &pSMBr);
971 if (rc)
972 return rc;
973
974 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -0600975 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
Pavel Shilovskyf4367202012-03-17 11:41:12 +0300976 PATH_MAX, cifs_sb->local_nls,
977 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 name_len++; /* trailing null */
979 name_len *= 2;
Steve French09d1db52005-04-28 22:41:08 -0700980 } else { /* BB improve check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 name_len = strnlen(name, PATH_MAX);
982 name_len++; /* trailing null */
983 strncpy(pSMB->DirName, name, name_len);
984 }
985
986 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +0000987 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 pSMB->ByteCount = cpu_to_le16(name_len + 1);
989 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
990 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +0400991 cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
Steve Frenchad7a2922008-02-07 23:25:02 +0000992 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500993 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc);
Steve Frencha5a2b482005-08-20 21:42:53 -0700994
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 cifs_buf_release(pSMB);
996 if (rc == -EAGAIN)
997 goto MkDirRetry;
998 return rc;
999}
1000
Steve French2dd29d32007-04-23 22:07:35 +00001001int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001002CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
1003 __u32 posix_flags, __u64 mode, __u16 *netfid,
1004 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
1005 const char *name, const struct nls_table *nls_codepage,
1006 int remap)
Steve French2dd29d32007-04-23 22:07:35 +00001007{
1008 TRANSACTION2_SPI_REQ *pSMB = NULL;
1009 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1010 int name_len;
1011 int rc = 0;
1012 int bytes_returned = 0;
Steve French2dd29d32007-04-23 22:07:35 +00001013 __u16 params, param_offset, offset, byte_count, count;
Steve Frenchad7a2922008-02-07 23:25:02 +00001014 OPEN_PSX_REQ *pdata;
1015 OPEN_PSX_RSP *psx_rsp;
Steve French2dd29d32007-04-23 22:07:35 +00001016
Joe Perchesf96637b2013-05-04 22:12:25 -05001017 cifs_dbg(FYI, "In POSIX Create\n");
Steve French2dd29d32007-04-23 22:07:35 +00001018PsxCreat:
1019 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1020 (void **) &pSMBr);
1021 if (rc)
1022 return rc;
1023
1024 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1025 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06001026 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1027 PATH_MAX, nls_codepage, remap);
Steve French2dd29d32007-04-23 22:07:35 +00001028 name_len++; /* trailing null */
1029 name_len *= 2;
1030 } else { /* BB improve the check for buffer overruns BB */
1031 name_len = strnlen(name, PATH_MAX);
1032 name_len++; /* trailing null */
1033 strncpy(pSMB->FileName, name, name_len);
1034 }
1035
1036 params = 6 + name_len;
1037 count = sizeof(OPEN_PSX_REQ);
1038 pSMB->MaxParameterCount = cpu_to_le16(2);
1039 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1040 pSMB->MaxSetupCount = 0;
1041 pSMB->Reserved = 0;
1042 pSMB->Flags = 0;
1043 pSMB->Timeout = 0;
1044 pSMB->Reserved2 = 0;
1045 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00001046 InformationLevel) - 4;
Steve French2dd29d32007-04-23 22:07:35 +00001047 offset = param_offset + params;
Steve French2dd29d32007-04-23 22:07:35 +00001048 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001049 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
Steve French2dd29d32007-04-23 22:07:35 +00001050 pdata->Permissions = cpu_to_le64(mode);
Steve French50c2f752007-07-13 00:33:32 +00001051 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
Steve French2dd29d32007-04-23 22:07:35 +00001052 pdata->OpenFlags = cpu_to_le32(*pOplock);
1053 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1054 pSMB->DataOffset = cpu_to_le16(offset);
1055 pSMB->SetupCount = 1;
1056 pSMB->Reserved3 = 0;
1057 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1058 byte_count = 3 /* pad */ + params + count;
1059
1060 pSMB->DataCount = cpu_to_le16(count);
1061 pSMB->ParameterCount = cpu_to_le16(params);
1062 pSMB->TotalDataCount = pSMB->DataCount;
1063 pSMB->TotalParameterCount = pSMB->ParameterCount;
1064 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1065 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001066 inc_rfc1001_len(pSMB, byte_count);
Steve French2dd29d32007-04-23 22:07:35 +00001067 pSMB->ByteCount = cpu_to_le16(byte_count);
1068 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1069 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1070 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001071 cifs_dbg(FYI, "Posix create returned %d\n", rc);
Steve French2dd29d32007-04-23 22:07:35 +00001072 goto psx_create_err;
1073 }
1074
Joe Perchesf96637b2013-05-04 22:12:25 -05001075 cifs_dbg(FYI, "copying inode info\n");
Steve French2dd29d32007-04-23 22:07:35 +00001076 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1077
Jeff Layton820a8032011-05-04 08:05:26 -04001078 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
Steve French2dd29d32007-04-23 22:07:35 +00001079 rc = -EIO; /* bad smb */
1080 goto psx_create_err;
1081 }
1082
1083 /* copy return information to pRetData */
Steve French50c2f752007-07-13 00:33:32 +00001084 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
Steve French2dd29d32007-04-23 22:07:35 +00001085 + le16_to_cpu(pSMBr->t2.DataOffset));
Steve French50c2f752007-07-13 00:33:32 +00001086
Steve French2dd29d32007-04-23 22:07:35 +00001087 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
Steve French790fe572007-07-07 19:25:05 +00001088 if (netfid)
Steve French2dd29d32007-04-23 22:07:35 +00001089 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1090 /* Let caller know file was created so we can set the mode. */
1091 /* Do we care about the CreateAction in any other cases? */
Steve French790fe572007-07-07 19:25:05 +00001092 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
Steve French2dd29d32007-04-23 22:07:35 +00001093 *pOplock |= CIFS_CREATE_ACTION;
1094 /* check to make sure response data is there */
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001095 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1096 pRetData->Type = cpu_to_le32(-1); /* unknown */
Joe Perchesf96637b2013-05-04 22:12:25 -05001097 cifs_dbg(NOISY, "unknown type\n");
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001098 } else {
Jeff Layton820a8032011-05-04 08:05:26 -04001099 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
Steve French2dd29d32007-04-23 22:07:35 +00001100 + sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001101 cifs_dbg(VFS, "Open response data too small\n");
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001102 pRetData->Type = cpu_to_le32(-1);
Steve French2dd29d32007-04-23 22:07:35 +00001103 goto psx_create_err;
1104 }
Steve French50c2f752007-07-13 00:33:32 +00001105 memcpy((char *) pRetData,
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001106 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
Steve French26f57362007-08-30 22:09:15 +00001107 sizeof(FILE_UNIX_BASIC_INFO));
Steve French2dd29d32007-04-23 22:07:35 +00001108 }
Steve French2dd29d32007-04-23 22:07:35 +00001109
1110psx_create_err:
1111 cifs_buf_release(pSMB);
1112
Steve French65bc98b2009-07-10 15:27:25 +00001113 if (posix_flags & SMB_O_DIRECTORY)
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001114 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
Steve French65bc98b2009-07-10 15:27:25 +00001115 else
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001116 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
Steve French2dd29d32007-04-23 22:07:35 +00001117
1118 if (rc == -EAGAIN)
1119 goto PsxCreat;
1120
Steve French50c2f752007-07-13 00:33:32 +00001121 return rc;
Steve French2dd29d32007-04-23 22:07:35 +00001122}
1123
Steve Frencha9d02ad2005-08-24 23:06:05 -07001124static __u16 convert_disposition(int disposition)
1125{
1126 __u16 ofun = 0;
1127
1128 switch (disposition) {
1129 case FILE_SUPERSEDE:
1130 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1131 break;
1132 case FILE_OPEN:
1133 ofun = SMBOPEN_OAPPEND;
1134 break;
1135 case FILE_CREATE:
1136 ofun = SMBOPEN_OCREATE;
1137 break;
1138 case FILE_OPEN_IF:
1139 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1140 break;
1141 case FILE_OVERWRITE:
1142 ofun = SMBOPEN_OTRUNC;
1143 break;
1144 case FILE_OVERWRITE_IF:
1145 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1146 break;
1147 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001148 cifs_dbg(FYI, "unknown disposition %d\n", disposition);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001149 ofun = SMBOPEN_OAPPEND; /* regular open */
1150 }
1151 return ofun;
1152}
1153
Jeff Layton35fc37d2008-05-14 10:22:03 -07001154static int
1155access_flags_to_smbopen_mode(const int access_flags)
1156{
1157 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1158
1159 if (masked_flags == GENERIC_READ)
1160 return SMBOPEN_READ;
1161 else if (masked_flags == GENERIC_WRITE)
1162 return SMBOPEN_WRITE;
1163
1164 /* just go for read/write */
1165 return SMBOPEN_READWRITE;
1166}
1167
Steve Frencha9d02ad2005-08-24 23:06:05 -07001168int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001169SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001170 const char *fileName, const int openDisposition,
Steve Frenchad7a2922008-02-07 23:25:02 +00001171 const int access_flags, const int create_options, __u16 *netfid,
1172 int *pOplock, FILE_ALL_INFO *pfile_info,
Steve Frencha9d02ad2005-08-24 23:06:05 -07001173 const struct nls_table *nls_codepage, int remap)
1174{
1175 int rc = -EACCES;
1176 OPENX_REQ *pSMB = NULL;
1177 OPENX_RSP *pSMBr = NULL;
1178 int bytes_returned;
1179 int name_len;
1180 __u16 count;
1181
1182OldOpenRetry:
1183 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1184 (void **) &pSMBr);
1185 if (rc)
1186 return rc;
1187
1188 pSMB->AndXCommand = 0xFF; /* none */
1189
1190 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1191 count = 1; /* account for one byte pad to word boundary */
1192 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06001193 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1194 fileName, PATH_MAX, nls_codepage, remap);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001195 name_len++; /* trailing null */
1196 name_len *= 2;
1197 } else { /* BB improve check for buffer overruns BB */
1198 count = 0; /* no pad */
1199 name_len = strnlen(fileName, PATH_MAX);
1200 name_len++; /* trailing null */
1201 strncpy(pSMB->fileName, fileName, name_len);
1202 }
1203 if (*pOplock & REQ_OPLOCK)
1204 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001205 else if (*pOplock & REQ_BATCHOPLOCK)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001206 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
Steve French26f57362007-08-30 22:09:15 +00001207
Steve Frencha9d02ad2005-08-24 23:06:05 -07001208 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
Jeff Layton35fc37d2008-05-14 10:22:03 -07001209 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001210 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1211 /* set file as system file if special file such
1212 as fifo and server expecting SFU style and
1213 no Unix extensions */
1214
Steve French790fe572007-07-07 19:25:05 +00001215 if (create_options & CREATE_OPTION_SPECIAL)
1216 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
Steve Frenchad7a2922008-02-07 23:25:02 +00001217 else /* BB FIXME BB */
1218 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001219
Jeff Layton67750fb2008-05-09 22:28:02 +00001220 if (create_options & CREATE_OPTION_READONLY)
1221 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001222
1223 /* BB FIXME BB */
Steve French50c2f752007-07-13 00:33:32 +00001224/* pSMB->CreateOptions = cpu_to_le32(create_options &
1225 CREATE_OPTIONS_MASK); */
Steve Frencha9d02ad2005-08-24 23:06:05 -07001226 /* BB FIXME END BB */
Steve French3e87d802005-09-18 20:49:21 -07001227
1228 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
Steve French70ca7342005-09-22 16:32:06 -07001229 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001230 count += name_len;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001231 inc_rfc1001_len(pSMB, count);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001232
1233 pSMB->ByteCount = cpu_to_le16(count);
1234 /* long_op set to 1 to allow for oplock break timeouts */
1235 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Jeff Layton77499812011-01-11 07:24:23 -05001236 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001237 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001238 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001239 cifs_dbg(FYI, "Error in Open = %d\n", rc);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001240 } else {
1241 /* BB verify if wct == 15 */
1242
Steve French582d21e2008-05-13 04:54:12 +00001243/* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
Steve Frencha9d02ad2005-08-24 23:06:05 -07001244
1245 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1246 /* Let caller know file was created so we can set the mode. */
1247 /* Do we care about the CreateAction in any other cases? */
1248 /* BB FIXME BB */
Steve French790fe572007-07-07 19:25:05 +00001249/* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
Steve Frencha9d02ad2005-08-24 23:06:05 -07001250 *pOplock |= CIFS_CREATE_ACTION; */
1251 /* BB FIXME END */
1252
Steve French790fe572007-07-07 19:25:05 +00001253 if (pfile_info) {
Steve Frencha9d02ad2005-08-24 23:06:05 -07001254 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1255 pfile_info->LastAccessTime = 0; /* BB fixme */
1256 pfile_info->LastWriteTime = 0; /* BB fixme */
1257 pfile_info->ChangeTime = 0; /* BB fixme */
Steve French70ca7342005-09-22 16:32:06 -07001258 pfile_info->Attributes =
Steve French50c2f752007-07-13 00:33:32 +00001259 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
Steve Frencha9d02ad2005-08-24 23:06:05 -07001260 /* the file_info buf is endian converted by caller */
Steve French70ca7342005-09-22 16:32:06 -07001261 pfile_info->AllocationSize =
1262 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1263 pfile_info->EndOfFile = pfile_info->AllocationSize;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001264 pfile_info->NumberOfLinks = cpu_to_le32(1);
Jeff Layton9a8165f2008-10-17 21:03:20 -04001265 pfile_info->DeletePending = 0;
Steve Frencha9d02ad2005-08-24 23:06:05 -07001266 }
1267 }
1268
1269 cifs_buf_release(pSMB);
1270 if (rc == -EAGAIN)
1271 goto OldOpenRetry;
1272 return rc;
1273}
1274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275int
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001276CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,
1277 FILE_ALL_INFO *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278{
1279 int rc = -EACCES;
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001280 OPEN_REQ *req = NULL;
1281 OPEN_RSP *rsp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 int bytes_returned;
1283 int name_len;
1284 __u16 count;
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001285 struct cifs_sb_info *cifs_sb = oparms->cifs_sb;
1286 struct cifs_tcon *tcon = oparms->tcon;
1287 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
1288 const struct nls_table *nls = cifs_sb->local_nls;
1289 int create_options = oparms->create_options;
1290 int desired_access = oparms->desired_access;
1291 int disposition = oparms->disposition;
1292 const char *path = oparms->path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293
1294openRetry:
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001295 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **)&req,
1296 (void **)&rsp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 if (rc)
1298 return rc;
1299
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001300 /* no commands go after this */
1301 req->AndXCommand = 0xFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001303 if (req->hdr.Flags2 & SMBFLG2_UNICODE) {
1304 /* account for one byte pad to word boundary */
1305 count = 1;
1306 name_len = cifsConvertToUTF16((__le16 *)(req->fileName + 1),
1307 path, PATH_MAX, nls, remap);
1308 /* trailing null */
1309 name_len++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 name_len *= 2;
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001311 req->NameLength = cpu_to_le16(name_len);
1312 } else {
1313 /* BB improve check for buffer overruns BB */
1314 /* no pad */
1315 count = 0;
1316 name_len = strnlen(path, PATH_MAX);
1317 /* trailing null */
1318 name_len++;
1319 req->NameLength = cpu_to_le16(name_len);
1320 strncpy(req->fileName, path, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 }
Jeff Layton67750fb2008-05-09 22:28:02 +00001322
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001323 if (*oplock & REQ_OPLOCK)
1324 req->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1325 else if (*oplock & REQ_BATCHOPLOCK)
1326 req->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1327
1328 req->DesiredAccess = cpu_to_le32(desired_access);
1329 req->AllocationSize = 0;
1330
1331 /*
1332 * Set file as system file if special file such as fifo and server
1333 * expecting SFU style and no Unix extensions.
1334 */
1335 if (create_options & CREATE_OPTION_SPECIAL)
1336 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1337 else
1338 req->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1339
1340 /*
1341 * XP does not handle ATTR_POSIX_SEMANTICS but it helps speed up case
1342 * sensitive checks for other servers such as Samba.
1343 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 if (tcon->ses->capabilities & CAP_UNIX)
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001345 req->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Jeff Layton67750fb2008-05-09 22:28:02 +00001347 if (create_options & CREATE_OPTION_READONLY)
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001348 req->FileAttributes |= cpu_to_le32(ATTR_READONLY);
Jeff Layton67750fb2008-05-09 22:28:02 +00001349
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001350 req->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1351 req->CreateDisposition = cpu_to_le32(disposition);
1352 req->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1353
Steve French09d1db52005-04-28 22:41:08 -07001354 /* BB Expirement with various impersonation levels and verify */
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001355 req->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1356 req->SecurityFlags = SECURITY_CONTEXT_TRACKING|SECURITY_EFFECTIVE_ONLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357
1358 count += name_len;
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001359 inc_rfc1001_len(req, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001361 req->ByteCount = cpu_to_le16(count);
1362 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)req,
1363 (struct smb_hdr *)rsp, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001364 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001366 cifs_dbg(FYI, "Error in Open = %d\n", rc);
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001367 cifs_buf_release(req);
1368 if (rc == -EAGAIN)
1369 goto openRetry;
1370 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 }
Steve Frencha5a2b482005-08-20 21:42:53 -07001372
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001373 /* 1 byte no need to le_to_cpu */
1374 *oplock = rsp->OplockLevel;
1375 /* cifs fid stays in le */
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +04001376 oparms->fid->netfid = rsp->Fid;
Pavel Shilovsky9bf4fa02014-01-16 15:53:33 +04001377
1378 /* Let caller know file was created so we can set the mode. */
1379 /* Do we care about the CreateAction in any other cases? */
1380 if (cpu_to_le32(FILE_CREATE) == rsp->CreateAction)
1381 *oplock |= CIFS_CREATE_ACTION;
1382
1383 if (buf) {
1384 /* copy from CreationTime to Attributes */
1385 memcpy((char *)buf, (char *)&rsp->CreationTime, 36);
1386 /* the file_info buf is endian converted by caller */
1387 buf->AllocationSize = rsp->AllocationSize;
1388 buf->EndOfFile = rsp->EndOfFile;
1389 buf->NumberOfLinks = cpu_to_le32(1);
1390 buf->DeletePending = 0;
1391 }
1392
1393 cifs_buf_release(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 return rc;
1395}
1396
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001397/*
1398 * Discard any remaining data in the current SMB. To do this, we borrow the
1399 * current bigbuf.
1400 */
1401static int
1402cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1403{
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001404 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001405 int remaining = rfclen + 4 - server->total_read;
1406 struct cifs_readdata *rdata = mid->callback_data;
1407
1408 while (remaining > 0) {
1409 int length;
1410
1411 length = cifs_read_from_socket(server, server->bigbuf,
1412 min_t(unsigned int, remaining,
Pavel Shilovsky1887f602012-05-17 12:45:31 +04001413 CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001414 if (length < 0)
1415 return length;
1416 server->total_read += length;
1417 remaining -= length;
1418 }
1419
1420 dequeue_mid(mid, rdata->result);
1421 return 0;
1422}
1423
Pavel Shilovsky09a47072012-09-18 16:20:29 -07001424int
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001425cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1426{
1427 int length, len;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04001428 unsigned int data_offset, data_len;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001429 struct cifs_readdata *rdata = mid->callback_data;
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001430 char *buf = server->smallbuf;
1431 unsigned int buflen = get_rfc1002_length(buf) + 4;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001432
Joe Perchesf96637b2013-05-04 22:12:25 -05001433 cifs_dbg(FYI, "%s: mid=%llu offset=%llu bytes=%u\n",
1434 __func__, mid->mid, rdata->offset, rdata->bytes);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001435
1436 /*
1437 * read the rest of READ_RSP header (sans Data array), or whatever we
1438 * can if there's not enough data. At this point, we've read down to
1439 * the Mid.
1440 */
Pavel Shilovskyeb378712012-05-17 13:02:51 +04001441 len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
Pavel Shilovsky1887f602012-05-17 12:45:31 +04001442 HEADER_SIZE(server) + 1;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001443
Jeff Layton58195752012-09-19 06:22:34 -07001444 rdata->iov.iov_base = buf + HEADER_SIZE(server) - 1;
1445 rdata->iov.iov_len = len;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001446
Jeff Layton58195752012-09-19 06:22:34 -07001447 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001448 if (length < 0)
1449 return length;
1450 server->total_read += length;
1451
1452 /* Was the SMB read successful? */
Pavel Shilovskyeb378712012-05-17 13:02:51 +04001453 rdata->result = server->ops->map_error(buf, false);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001454 if (rdata->result != 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001455 cifs_dbg(FYI, "%s: server returned error %d\n",
1456 __func__, rdata->result);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001457 return cifs_readv_discard(server, mid);
1458 }
1459
1460 /* Is there enough to get to the rest of the READ_RSP header? */
Pavel Shilovskyeb378712012-05-17 13:02:51 +04001461 if (server->total_read < server->vals->read_rsp_size) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001462 cifs_dbg(FYI, "%s: server returned short header. got=%u expected=%zu\n",
1463 __func__, server->total_read,
1464 server->vals->read_rsp_size);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001465 rdata->result = -EIO;
1466 return cifs_readv_discard(server, mid);
1467 }
1468
Pavel Shilovskyeb378712012-05-17 13:02:51 +04001469 data_offset = server->ops->read_data_offset(buf) + 4;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001470 if (data_offset < server->total_read) {
1471 /*
1472 * win2k8 sometimes sends an offset of 0 when the read
1473 * is beyond the EOF. Treat it as if the data starts just after
1474 * the header.
1475 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001476 cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n",
1477 __func__, data_offset);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001478 data_offset = server->total_read;
1479 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1480 /* data_offset is beyond the end of smallbuf */
Joe Perchesf96637b2013-05-04 22:12:25 -05001481 cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n",
1482 __func__, data_offset);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001483 rdata->result = -EIO;
1484 return cifs_readv_discard(server, mid);
1485 }
1486
Joe Perchesf96637b2013-05-04 22:12:25 -05001487 cifs_dbg(FYI, "%s: total_read=%u data_offset=%u\n",
1488 __func__, server->total_read, data_offset);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001489
1490 len = data_offset - server->total_read;
1491 if (len > 0) {
1492 /* read any junk before data into the rest of smallbuf */
Jeff Layton58195752012-09-19 06:22:34 -07001493 rdata->iov.iov_base = buf + server->total_read;
1494 rdata->iov.iov_len = len;
1495 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001496 if (length < 0)
1497 return length;
1498 server->total_read += length;
1499 }
1500
1501 /* set up first iov for signature check */
Jeff Layton58195752012-09-19 06:22:34 -07001502 rdata->iov.iov_base = buf;
1503 rdata->iov.iov_len = server->total_read;
Joe Perchesf96637b2013-05-04 22:12:25 -05001504 cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n",
1505 rdata->iov.iov_base, rdata->iov.iov_len);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001506
1507 /* how much data is in the response? */
Pavel Shilovskyeb378712012-05-17 13:02:51 +04001508 data_len = server->ops->read_data_length(buf);
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001509 if (data_offset + data_len > buflen) {
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001510 /* data_len is corrupt -- discard frame */
1511 rdata->result = -EIO;
1512 return cifs_readv_discard(server, mid);
1513 }
1514
Jeff Layton8321fec2012-09-19 06:22:32 -07001515 length = rdata->read_into_pages(server, rdata, data_len);
1516 if (length < 0)
1517 return length;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001518
Jeff Layton8321fec2012-09-19 06:22:32 -07001519 server->total_read += length;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001520 rdata->bytes = length;
1521
Joe Perchesf96637b2013-05-04 22:12:25 -05001522 cifs_dbg(FYI, "total_read=%u buflen=%u remaining=%u\n",
1523 server->total_read, buflen, data_len);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001524
1525 /* discard anything left over */
Pavel Shilovsky5ffef7b2012-03-23 14:28:03 -04001526 if (server->total_read < buflen)
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001527 return cifs_readv_discard(server, mid);
1528
1529 dequeue_mid(mid, false);
1530 return length;
1531}
1532
1533static void
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001534cifs_readv_callback(struct mid_q_entry *mid)
1535{
1536 struct cifs_readdata *rdata = mid->callback_data;
1537 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1538 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Layton58195752012-09-19 06:22:34 -07001539 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
1540 .rq_nvec = 1,
Jeff Layton8321fec2012-09-19 06:22:32 -07001541 .rq_pages = rdata->pages,
1542 .rq_npages = rdata->nr_pages,
1543 .rq_pagesz = rdata->pagesz,
1544 .rq_tailsz = rdata->tailsz };
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001545
Joe Perchesf96637b2013-05-04 22:12:25 -05001546 cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1547 __func__, mid->mid, mid->mid_state, rdata->result,
1548 rdata->bytes);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001549
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001550 switch (mid->mid_state) {
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001551 case MID_RESPONSE_RECEIVED:
1552 /* result already set, check signature */
Jeff Layton38d77c52013-05-26 07:01:00 -04001553 if (server->sign) {
Steve French985e4ff02012-08-03 09:42:45 -05001554 int rc = 0;
1555
Jeff Laytonbf5ea0e2012-09-18 16:20:34 -07001556 rc = cifs_verify_signature(&rqst, server,
Jeff Layton0124cc42013-04-03 11:55:03 -04001557 mid->sequence_number);
Steve French985e4ff02012-08-03 09:42:45 -05001558 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05001559 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
1560 rc);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001561 }
1562 /* FIXME: should this be counted toward the initiating task? */
1563 task_io_account_read(rdata->bytes);
1564 cifs_stats_bytes_read(tcon, rdata->bytes);
1565 break;
1566 case MID_REQUEST_SUBMITTED:
1567 case MID_RETRY_NEEDED:
1568 rdata->result = -EAGAIN;
1569 break;
1570 default:
1571 rdata->result = -EIO;
1572 }
1573
Jeff Laytonda472fc2012-03-23 14:40:53 -04001574 queue_work(cifsiod_wq, &rdata->work);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001575 DeleteMidQEntry(mid);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04001576 add_credits(server, 1, 0);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001577}
1578
1579/* cifs_async_readv - send an async write, and set up mid to handle result */
1580int
1581cifs_async_readv(struct cifs_readdata *rdata)
1582{
1583 int rc;
1584 READ_REQ *smb = NULL;
1585 int wct;
1586 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
Jeff Layton58195752012-09-19 06:22:34 -07001587 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
Jeff Laytonfec344e2012-09-18 16:20:35 -07001588 .rq_nvec = 1 };
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001589
Joe Perchesf96637b2013-05-04 22:12:25 -05001590 cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
1591 __func__, rdata->offset, rdata->bytes);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001592
1593 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1594 wct = 12;
1595 else {
1596 wct = 10; /* old style read */
1597 if ((rdata->offset >> 32) > 0) {
1598 /* can not handle this big offset for old */
1599 return -EIO;
1600 }
1601 }
1602
1603 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1604 if (rc)
1605 return rc;
1606
1607 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1608 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1609
1610 smb->AndXCommand = 0xFF; /* none */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001611 smb->Fid = rdata->cfile->fid.netfid;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001612 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1613 if (wct == 12)
1614 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1615 smb->Remaining = 0;
1616 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1617 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1618 if (wct == 12)
1619 smb->ByteCount = 0;
1620 else {
1621 /* old style read */
1622 struct smb_com_readx_req *smbr =
1623 (struct smb_com_readx_req *)smb;
1624 smbr->ByteCount = 0;
1625 }
1626
1627 /* 4 for RFC1001 length + 1 for BCC */
Jeff Layton58195752012-09-19 06:22:34 -07001628 rdata->iov.iov_base = smb;
1629 rdata->iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001630
Jeff Layton6993f742012-05-16 07:13:17 -04001631 kref_get(&rdata->refcount);
Jeff Laytonfec344e2012-09-18 16:20:35 -07001632 rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
1633 cifs_readv_callback, rdata, 0);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001634
1635 if (rc == 0)
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001636 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
Jeff Layton6993f742012-05-16 07:13:17 -04001637 else
1638 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Laytone28bc5b2011-10-19 15:30:07 -04001639
1640 cifs_small_buf_release(smb);
1641 return rc;
1642}
1643
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001645CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
1646 unsigned int *nbytes, char **buf, int *pbuf_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
1648 int rc = -EACCES;
1649 READ_REQ *pSMB = NULL;
1650 READ_RSP *pSMBr = NULL;
1651 char *pReadData = NULL;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001652 int wct;
Steve Frenchec637e32005-12-12 20:53:18 -08001653 int resp_buf_type = 0;
1654 struct kvec iov[1];
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001655 __u32 pid = io_parms->pid;
1656 __u16 netfid = io_parms->netfid;
1657 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001658 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001659 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Joe Perchesf96637b2013-05-04 22:12:25 -05001661 cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid);
Steve French790fe572007-07-07 19:25:05 +00001662 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001663 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001664 else {
Steve Frenchbfa0d752005-08-31 21:50:37 -07001665 wct = 10; /* old style read */
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001666 if ((offset >> 32) > 0) {
Steve French4c3130e2008-12-09 00:28:16 +00001667 /* can not handle this big offset for old */
1668 return -EIO;
1669 }
1670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671
1672 *nbytes = 0;
Steve Frenchec637e32005-12-12 20:53:18 -08001673 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 if (rc)
1675 return rc;
1676
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001677 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1678 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1679
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 /* tcon and ses pointer are checked in smb_init */
1681 if (tcon->ses->server == NULL)
1682 return -ECONNABORTED;
1683
Steve Frenchec637e32005-12-12 20:53:18 -08001684 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 pSMB->Fid = netfid;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001686 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001687 if (wct == 12)
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001688 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve Frenchbfa0d752005-08-31 21:50:37 -07001689
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 pSMB->Remaining = 0;
1691 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1692 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
Steve French790fe572007-07-07 19:25:05 +00001693 if (wct == 12)
Steve Frenchbfa0d752005-08-31 21:50:37 -07001694 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1695 else {
1696 /* old style read */
Steve French50c2f752007-07-13 00:33:32 +00001697 struct smb_com_readx_req *pSMBW =
Steve Frenchbfa0d752005-08-31 21:50:37 -07001698 (struct smb_com_readx_req *)pSMB;
Steve Frenchec637e32005-12-12 20:53:18 -08001699 pSMBW->ByteCount = 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001700 }
Steve Frenchec637e32005-12-12 20:53:18 -08001701
1702 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001703 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve Frencha761ac52007-10-18 21:45:27 +00001704 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
Jeff Layton77499812011-01-11 07:24:23 -05001705 &resp_buf_type, CIFS_LOG_ERROR);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001706 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
Steve Frenchec637e32005-12-12 20:53:18 -08001707 pSMBr = (READ_RSP *)iov[0].iov_base;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001709 cifs_dbg(VFS, "Send error in read = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 } else {
1711 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1712 data_length = data_length << 16;
1713 data_length += le16_to_cpu(pSMBr->DataLength);
1714 *nbytes = data_length;
1715
1716 /*check that DataLength would not go beyond end of SMB */
Steve Frenchec637e32005-12-12 20:53:18 -08001717 if ((data_length > CIFSMaxBufSize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 || (data_length > count)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001719 cifs_dbg(FYI, "bad length %d for count %d\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00001720 data_length, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 rc = -EIO;
1722 *nbytes = 0;
1723 } else {
Steve Frenchec637e32005-12-12 20:53:18 -08001724 pReadData = (char *) (&pSMBr->hdr.Protocol) +
Steve French26f57362007-08-30 22:09:15 +00001725 le16_to_cpu(pSMBr->DataOffset);
1726/* if (rc = copy_to_user(buf, pReadData, data_length)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001727 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
Steve French50c2f752007-07-13 00:33:32 +00001728 rc = -EFAULT;
Steve French26f57362007-08-30 22:09:15 +00001729 }*/ /* can not use copy_to_user when using page cache*/
Steve French790fe572007-07-07 19:25:05 +00001730 if (*buf)
Steve French50c2f752007-07-13 00:33:32 +00001731 memcpy(*buf, pReadData, data_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 }
1733 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
Steve French4b8f9302006-02-26 16:41:18 +00001735/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00001736 if (*buf) {
1737 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001738 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001739 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001740 cifs_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00001741 } else if (resp_buf_type != CIFS_NO_BUFFER) {
Steve French50c2f752007-07-13 00:33:32 +00001742 /* return buffer to caller to free */
1743 *buf = iov[0].iov_base;
Steve French790fe572007-07-07 19:25:05 +00001744 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001745 *pbuf_type = CIFS_SMALL_BUFFER;
Steve French790fe572007-07-07 19:25:05 +00001746 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001747 *pbuf_type = CIFS_LARGE_BUFFER;
Steve French6cec2ae2006-02-22 17:31:52 -06001748 } /* else no valid buffer on return - leave as null */
Steve Frenchec637e32005-12-12 20:53:18 -08001749
1750 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 since file handle passed in no longer valid */
1752 return rc;
1753}
1754
Steve Frenchec637e32005-12-12 20:53:18 -08001755
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001757CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001758 unsigned int *nbytes, const char *buf,
Steve French50c2f752007-07-13 00:33:32 +00001759 const char __user *ubuf, const int long_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760{
1761 int rc = -EACCES;
1762 WRITE_REQ *pSMB = NULL;
1763 WRITE_RSP *pSMBr = NULL;
Steve French1c955182005-08-30 20:58:07 -07001764 int bytes_returned, wct;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 __u32 bytes_sent;
1766 __u16 byte_count;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001767 __u32 pid = io_parms->pid;
1768 __u16 netfid = io_parms->netfid;
1769 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00001770 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001771 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
Steve Frencha24e2d72010-04-03 17:20:21 +00001773 *nbytes = 0;
1774
Joe Perchesf96637b2013-05-04 22:12:25 -05001775 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
Steve French790fe572007-07-07 19:25:05 +00001776 if (tcon->ses == NULL)
Steve French1c955182005-08-30 20:58:07 -07001777 return -ECONNABORTED;
1778
Steve French790fe572007-07-07 19:25:05 +00001779 if (tcon->ses->capabilities & CAP_LARGE_FILES)
Steve French1c955182005-08-30 20:58:07 -07001780 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00001781 else {
Steve French1c955182005-08-30 20:58:07 -07001782 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00001783 if ((offset >> 32) > 0) {
1784 /* can not handle big offset for old srv */
1785 return -EIO;
1786 }
1787 }
Steve French1c955182005-08-30 20:58:07 -07001788
1789 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 (void **) &pSMBr);
1791 if (rc)
1792 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001793
1794 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1795 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 /* tcon and ses pointer are checked in smb_init */
1798 if (tcon->ses->server == NULL)
1799 return -ECONNABORTED;
1800
1801 pSMB->AndXCommand = 0xFF; /* none */
1802 pSMB->Fid = netfid;
1803 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00001804 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001805 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Steve French50c2f752007-07-13 00:33:32 +00001806
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 pSMB->Reserved = 0xFFFFFFFF;
1808 pSMB->WriteMode = 0;
1809 pSMB->Remaining = 0;
1810
Steve French50c2f752007-07-13 00:33:32 +00001811 /* Can increase buffer size if buffer is big enough in some cases ie we
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 can send more if LARGE_WRITE_X capability returned by the server and if
1813 our buffer is big enough or if we convert to iovecs on socket writes
1814 and eliminate the copy to the CIFS buffer */
Steve French790fe572007-07-07 19:25:05 +00001815 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1817 } else {
1818 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1819 & ~0xFF;
1820 }
1821
1822 if (bytes_sent > count)
1823 bytes_sent = count;
1824 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00001825 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Steve French790fe572007-07-07 19:25:05 +00001826 if (buf)
Steve French61e74802008-12-03 00:57:54 +00001827 memcpy(pSMB->Data, buf, bytes_sent);
Steve French790fe572007-07-07 19:25:05 +00001828 else if (ubuf) {
1829 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 cifs_buf_release(pSMB);
1831 return -EFAULT;
1832 }
Steve Frenche30dcf32005-09-20 20:49:16 -07001833 } else if (count != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 /* No buffer */
1835 cifs_buf_release(pSMB);
1836 return -EINVAL;
Steve Frenche30dcf32005-09-20 20:49:16 -07001837 } /* else setting file size with write of zero bytes */
Steve French790fe572007-07-07 19:25:05 +00001838 if (wct == 14)
Steve Frenche30dcf32005-09-20 20:49:16 -07001839 byte_count = bytes_sent + 1; /* pad */
Steve Frenchad7a2922008-02-07 23:25:02 +00001840 else /* wct == 12 */
Steve Frenche30dcf32005-09-20 20:49:16 -07001841 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
Steve Frenchad7a2922008-02-07 23:25:02 +00001842
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1844 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00001845 inc_rfc1001_len(pSMB, byte_count);
Steve French1c955182005-08-30 20:58:07 -07001846
Steve French790fe572007-07-07 19:25:05 +00001847 if (wct == 14)
Steve French1c955182005-08-30 20:58:07 -07001848 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00001849 else { /* old style write has byte count 4 bytes earlier
1850 so 4 bytes pad */
1851 struct smb_com_writex_req *pSMBW =
Steve French1c955182005-08-30 20:58:07 -07001852 (struct smb_com_writex_req *)pSMB;
1853 pSMBW->ByteCount = cpu_to_le16(byte_count);
1854 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855
1856 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1857 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04001858 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001860 cifs_dbg(FYI, "Send error in write = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 } else {
1862 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1863 *nbytes = (*nbytes) << 16;
1864 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05301865
1866 /*
1867 * Mask off high 16 bits when bytes written as returned by the
1868 * server is greater than bytes requested by the client. Some
1869 * OS/2 servers are known to set incorrect CountHigh values.
1870 */
1871 if (*nbytes > count)
1872 *nbytes &= 0xFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 }
1874
1875 cifs_buf_release(pSMB);
1876
Steve French50c2f752007-07-13 00:33:32 +00001877 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 since file handle passed in no longer valid */
1879
1880 return rc;
1881}
1882
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001883void
1884cifs_writedata_release(struct kref *refcount)
1885{
1886 struct cifs_writedata *wdata = container_of(refcount,
1887 struct cifs_writedata, refcount);
1888
1889 if (wdata->cfile)
1890 cifsFileInfo_put(wdata->cfile);
1891
1892 kfree(wdata);
1893}
1894
1895/*
1896 * Write failed with a retryable error. Resend the write request. It's also
1897 * possible that the page was redirtied so re-clean the page.
1898 */
1899static void
1900cifs_writev_requeue(struct cifs_writedata *wdata)
1901{
1902 int i, rc;
1903 struct inode *inode = wdata->cfile->dentry->d_inode;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07001904 struct TCP_Server_Info *server;
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001905
1906 for (i = 0; i < wdata->nr_pages; i++) {
1907 lock_page(wdata->pages[i]);
1908 clear_page_dirty_for_io(wdata->pages[i]);
1909 }
1910
1911 do {
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07001912 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
Steve French4a5c80d2014-02-07 20:45:12 -06001913 rc = server->ops->async_writev(wdata, cifs_writedata_release);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001914 } while (rc == -EAGAIN);
1915
1916 for (i = 0; i < wdata->nr_pages; i++) {
Jeff Layton94e18002013-03-04 15:18:25 -05001917 unlock_page(wdata->pages[i]);
Ouyang Maochunc51bb0e2013-02-18 09:54:52 -06001918 if (rc != 0) {
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001919 SetPageError(wdata->pages[i]);
Ouyang Maochunc51bb0e2013-02-18 09:54:52 -06001920 end_page_writeback(wdata->pages[i]);
1921 page_cache_release(wdata->pages[i]);
1922 }
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001923 }
1924
1925 mapping_set_error(inode->i_mapping, rc);
1926 kref_put(&wdata->refcount, cifs_writedata_release);
1927}
1928
Jeff Laytonc2e87642012-03-23 14:40:55 -04001929void
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001930cifs_writev_complete(struct work_struct *work)
1931{
1932 struct cifs_writedata *wdata = container_of(work,
1933 struct cifs_writedata, work);
1934 struct inode *inode = wdata->cfile->dentry->d_inode;
1935 int i = 0;
1936
1937 if (wdata->result == 0) {
Jeff Layton597b0272012-03-23 14:40:56 -04001938 spin_lock(&inode->i_lock);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001939 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
Jeff Layton597b0272012-03-23 14:40:56 -04001940 spin_unlock(&inode->i_lock);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001941 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
1942 wdata->bytes);
1943 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
1944 return cifs_writev_requeue(wdata);
1945
1946 for (i = 0; i < wdata->nr_pages; i++) {
1947 struct page *page = wdata->pages[i];
1948 if (wdata->result == -EAGAIN)
1949 __set_page_dirty_nobuffers(page);
1950 else if (wdata->result < 0)
1951 SetPageError(page);
1952 end_page_writeback(page);
1953 page_cache_release(page);
1954 }
1955 if (wdata->result != -EAGAIN)
1956 mapping_set_error(inode->i_mapping, wdata->result);
1957 kref_put(&wdata->refcount, cifs_writedata_release);
1958}
1959
1960struct cifs_writedata *
Jeff Laytonc2e87642012-03-23 14:40:55 -04001961cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001962{
1963 struct cifs_writedata *wdata;
1964
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001965 /* writedata + number of page pointers */
1966 wdata = kzalloc(sizeof(*wdata) +
Jeff Layton26c8f0d2014-02-07 11:04:04 -05001967 sizeof(struct page *) * nr_pages, GFP_NOFS);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001968 if (wdata != NULL) {
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001969 kref_init(&wdata->refcount);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04001970 INIT_LIST_HEAD(&wdata->list);
1971 init_completion(&wdata->done);
1972 INIT_WORK(&wdata->work, complete);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001973 }
1974 return wdata;
1975}
1976
1977/*
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001978 * Check the mid_state and signature on received buffer (if any), and queue the
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001979 * workqueue completion task.
1980 */
1981static void
1982cifs_writev_callback(struct mid_q_entry *mid)
1983{
1984 struct cifs_writedata *wdata = mid->callback_data;
Steve French96daf2b2011-05-27 04:34:02 +00001985 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001986 unsigned int written;
1987 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
1988
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -04001989 switch (mid->mid_state) {
Jeff Laytonc28c89f2011-05-19 16:22:56 -04001990 case MID_RESPONSE_RECEIVED:
1991 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
1992 if (wdata->result != 0)
1993 break;
1994
1995 written = le16_to_cpu(smb->CountHigh);
1996 written <<= 16;
1997 written += le16_to_cpu(smb->Count);
1998 /*
1999 * Mask off high 16 bits when bytes written as returned
2000 * by the server is greater than bytes requested by the
2001 * client. OS/2 servers are known to set incorrect
2002 * CountHigh values.
2003 */
2004 if (written > wdata->bytes)
2005 written &= 0xFFFF;
2006
2007 if (written < wdata->bytes)
2008 wdata->result = -ENOSPC;
2009 else
2010 wdata->bytes = written;
2011 break;
2012 case MID_REQUEST_SUBMITTED:
2013 case MID_RETRY_NEEDED:
2014 wdata->result = -EAGAIN;
2015 break;
2016 default:
2017 wdata->result = -EIO;
2018 break;
2019 }
2020
Jeff Laytonda472fc2012-03-23 14:40:53 -04002021 queue_work(cifsiod_wq, &wdata->work);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002022 DeleteMidQEntry(mid);
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04002023 add_credits(tcon->ses->server, 1, 0);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002024}
2025
2026/* cifs_async_writev - send an async write, and set up mid to handle result */
2027int
Steve French4a5c80d2014-02-07 20:45:12 -06002028cifs_async_writev(struct cifs_writedata *wdata,
2029 void (*release)(struct kref *kref))
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002030{
Jeff Laytoneddb0792012-09-18 16:20:35 -07002031 int rc = -EACCES;
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002032 WRITE_REQ *smb = NULL;
2033 int wct;
Steve French96daf2b2011-05-27 04:34:02 +00002034 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
Jeff Laytoneddb0792012-09-18 16:20:35 -07002035 struct kvec iov;
Jeff Laytonfec344e2012-09-18 16:20:35 -07002036 struct smb_rqst rqst = { };
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002037
2038 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2039 wct = 14;
2040 } else {
2041 wct = 12;
2042 if (wdata->offset >> 32 > 0) {
2043 /* can not handle big offset for old srv */
2044 return -EIO;
2045 }
2046 }
2047
2048 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2049 if (rc)
2050 goto async_writev_out;
2051
Jeff Laytonfe5f5d22012-03-23 14:40:55 -04002052 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2053 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002054
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002055 smb->AndXCommand = 0xFF; /* none */
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07002056 smb->Fid = wdata->cfile->fid.netfid;
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002057 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2058 if (wct == 14)
2059 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2060 smb->Reserved = 0xFFFFFFFF;
2061 smb->WriteMode = 0;
2062 smb->Remaining = 0;
2063
2064 smb->DataOffset =
2065 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2066
2067 /* 4 for RFC1001 length + 1 for BCC */
Jeff Laytoneddb0792012-09-18 16:20:35 -07002068 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2069 iov.iov_base = smb;
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002070
Jeff Laytoneddb0792012-09-18 16:20:35 -07002071 rqst.rq_iov = &iov;
2072 rqst.rq_nvec = 1;
2073 rqst.rq_pages = wdata->pages;
2074 rqst.rq_npages = wdata->nr_pages;
2075 rqst.rq_pagesz = wdata->pagesz;
2076 rqst.rq_tailsz = wdata->tailsz;
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002077
Joe Perchesf96637b2013-05-04 22:12:25 -05002078 cifs_dbg(FYI, "async write at %llu %u bytes\n",
2079 wdata->offset, wdata->bytes);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002080
2081 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2082 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2083
2084 if (wct == 14) {
2085 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2086 put_bcc(wdata->bytes + 1, &smb->hdr);
2087 } else {
2088 /* wct == 12 */
2089 struct smb_com_writex_req *smbw =
2090 (struct smb_com_writex_req *)smb;
2091 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2092 put_bcc(wdata->bytes + 5, &smbw->hdr);
Jeff Laytoneddb0792012-09-18 16:20:35 -07002093 iov.iov_len += 4; /* pad bigger by four bytes */
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002094 }
2095
2096 kref_get(&wdata->refcount);
Jeff Laytonfec344e2012-09-18 16:20:35 -07002097 rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
2098 cifs_writev_callback, wdata, 0);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002099
2100 if (rc == 0)
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002101 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002102 else
Steve French4a5c80d2014-02-07 20:45:12 -06002103 kref_put(&wdata->refcount, release);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002104
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002105async_writev_out:
2106 cifs_small_buf_release(smb);
Jeff Laytonc28c89f2011-05-19 16:22:56 -04002107 return rc;
2108}
2109
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002110int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002111CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07002112 unsigned int *nbytes, struct kvec *iov, int n_vec)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113{
2114 int rc = -EACCES;
2115 WRITE_REQ *pSMB = NULL;
Steve Frenchec637e32005-12-12 20:53:18 -08002116 int wct;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002117 int smb_hdr_len;
Steve Frenchec637e32005-12-12 20:53:18 -08002118 int resp_buf_type = 0;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002119 __u32 pid = io_parms->pid;
2120 __u16 netfid = io_parms->netfid;
2121 __u64 offset = io_parms->offset;
Steve French96daf2b2011-05-27 04:34:02 +00002122 struct cifs_tcon *tcon = io_parms->tcon;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002123 unsigned int count = io_parms->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04002125 *nbytes = 0;
2126
Joe Perchesf96637b2013-05-04 22:12:25 -05002127 cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count);
Steve Frenchff7feac2005-11-15 16:45:16 -08002128
Steve French4c3130e2008-12-09 00:28:16 +00002129 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
Steve French8cc64c62005-10-03 13:49:43 -07002130 wct = 14;
Steve French4c3130e2008-12-09 00:28:16 +00002131 } else {
Steve French8cc64c62005-10-03 13:49:43 -07002132 wct = 12;
Steve French4c3130e2008-12-09 00:28:16 +00002133 if ((offset >> 32) > 0) {
2134 /* can not handle big offset for old srv */
2135 return -EIO;
2136 }
2137 }
Steve French8cc64c62005-10-03 13:49:43 -07002138 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 if (rc)
2140 return rc;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002141
2142 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2143 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2144
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 /* tcon and ses pointer are checked in smb_init */
2146 if (tcon->ses->server == NULL)
2147 return -ECONNABORTED;
2148
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002149 pSMB->AndXCommand = 0xFF; /* none */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 pSMB->Fid = netfid;
2151 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
Steve French790fe572007-07-07 19:25:05 +00002152 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002153 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 pSMB->Reserved = 0xFFFFFFFF;
2155 pSMB->WriteMode = 0;
2156 pSMB->Remaining = 0;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 pSMB->DataOffset =
Steve French50c2f752007-07-13 00:33:32 +00002159 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160
Steve French3e844692005-10-03 13:37:24 -07002161 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2162 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002163 /* header + 1 byte pad */
2164 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
Steve French790fe572007-07-07 19:25:05 +00002165 if (wct == 14)
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002166 inc_rfc1001_len(pSMB, count + 1);
Steve French8cc64c62005-10-03 13:49:43 -07002167 else /* wct == 12 */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002168 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
Steve French790fe572007-07-07 19:25:05 +00002169 if (wct == 14)
Steve French8cc64c62005-10-03 13:49:43 -07002170 pSMB->ByteCount = cpu_to_le16(count + 1);
2171 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
Steve French50c2f752007-07-13 00:33:32 +00002172 struct smb_com_writex_req *pSMBW =
Steve French8cc64c62005-10-03 13:49:43 -07002173 (struct smb_com_writex_req *)pSMB;
2174 pSMBW->ByteCount = cpu_to_le16(count + 5);
2175 }
Steve French3e844692005-10-03 13:37:24 -07002176 iov[0].iov_base = pSMB;
Steve French790fe572007-07-07 19:25:05 +00002177 if (wct == 14)
Steve Frenchec637e32005-12-12 20:53:18 -08002178 iov[0].iov_len = smb_hdr_len + 4;
2179 else /* wct == 12 pad bigger by four bytes */
2180 iov[0].iov_len = smb_hdr_len + 8;
Steve French50c2f752007-07-13 00:33:32 +00002181
Steve French3e844692005-10-03 13:37:24 -07002182
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07002183 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002184 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002186 cifs_dbg(FYI, "Send error Write2 = %d\n", rc);
Steve French790fe572007-07-07 19:25:05 +00002187 } else if (resp_buf_type == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -08002188 /* presumably this can not happen, but best to be safe */
2189 rc = -EIO;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002190 } else {
Steve Frenchad7a2922008-02-07 23:25:02 +00002191 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002192 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2193 *nbytes = (*nbytes) << 16;
2194 *nbytes += le16_to_cpu(pSMBr->Count);
Suresh Jayaraman6513a812010-03-31 12:00:03 +05302195
2196 /*
2197 * Mask off high 16 bits when bytes written as returned by the
2198 * server is greater than bytes requested by the client. OS/2
2199 * servers are known to set incorrect CountHigh values.
2200 */
2201 if (*nbytes > count)
2202 *nbytes &= 0xFFFF;
Steve French50c2f752007-07-13 00:33:32 +00002203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204
Steve French4b8f9302006-02-26 16:41:18 +00002205/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French790fe572007-07-07 19:25:05 +00002206 if (resp_buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002207 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00002208 else if (resp_buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002209 cifs_buf_release(iov[0].iov_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
Steve French50c2f752007-07-13 00:33:32 +00002211 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 since file handle passed in no longer valid */
2213
2214 return rc;
2215}
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002216
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002217int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
2218 const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04002219 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2220{
2221 int rc = 0;
2222 LOCK_REQ *pSMB = NULL;
2223 struct kvec iov[2];
2224 int resp_buf_type;
2225 __u16 count;
2226
Joe Perchesf96637b2013-05-04 22:12:25 -05002227 cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n",
2228 num_lock, num_unlock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04002229
2230 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2231 if (rc)
2232 return rc;
2233
2234 pSMB->Timeout = 0;
2235 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2236 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2237 pSMB->LockType = lock_type;
2238 pSMB->AndXCommand = 0xFF; /* none */
2239 pSMB->Fid = netfid; /* netfid stays le */
2240
2241 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2242 inc_rfc1001_len(pSMB, count);
2243 pSMB->ByteCount = cpu_to_le16(count);
2244
2245 iov[0].iov_base = (char *)pSMB;
2246 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2247 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2248 iov[1].iov_base = (char *)buf;
2249 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2250
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002251 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04002252 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2253 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002254 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04002255
2256 return rc;
2257}
Steve Frenchd6e04ae2005-06-13 13:24:43 -05002258
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002260CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002261 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 const __u64 offset, const __u32 numUnlock,
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002263 const __u32 numLock, const __u8 lockType,
2264 const bool waitFlag, const __u8 oplock_level)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265{
2266 int rc = 0;
2267 LOCK_REQ *pSMB = NULL;
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002268/* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269 int bytes_returned;
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04002270 int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 __u16 count;
2272
Joe Perchesf96637b2013-05-04 22:12:25 -05002273 cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n",
2274 (int)waitFlag, numLock);
Steve French46810cb2005-04-28 22:41:09 -07002275 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2276
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 if (rc)
2278 return rc;
2279
Steve French790fe572007-07-07 19:25:05 +00002280 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04002281 /* no response expected */
2282 flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 pSMB->Timeout = 0;
Steve French4b18f2a2008-04-29 00:06:05 +00002284 } else if (waitFlag) {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04002285 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2287 } else {
2288 pSMB->Timeout = 0;
2289 }
2290
2291 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2292 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2293 pSMB->LockType = lockType;
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002294 pSMB->OplockLevel = oplock_level;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 pSMB->AndXCommand = 0xFF; /* none */
2296 pSMB->Fid = smb_file_id; /* netfid stays le */
2297
Steve French790fe572007-07-07 19:25:05 +00002298 if ((numLock != 0) || (numUnlock != 0)) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002299 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 /* BB where to store pid high? */
2301 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2302 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2303 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2304 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2305 count = sizeof(LOCKING_ANDX_RANGE);
2306 } else {
2307 /* oplock break */
2308 count = 0;
2309 }
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002310 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 pSMB->ByteCount = cpu_to_le16(count);
2312
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002313 if (waitFlag) {
2314 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
Steve Frenchaaa9bbe2008-05-23 17:38:32 +00002315 (struct smb_hdr *) pSMB, &bytes_returned);
Steve French133672e2007-11-13 22:41:37 +00002316 cifs_small_buf_release(pSMB);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002317 } else {
Pavel Shilovskya891f0f2012-05-23 16:14:34 +04002318 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
Steve French133672e2007-11-13 22:41:37 +00002319 /* SMB buffer freed by function above */
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002320 }
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002321 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002322 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002323 cifs_dbg(FYI, "Send error in Lock = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
Steve French50c2f752007-07-13 00:33:32 +00002325 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 since file handle passed in no longer valid */
2327 return rc;
2328}
2329
2330int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002331CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04002332 const __u16 smb_file_id, const __u32 netpid,
2333 const loff_t start_offset, const __u64 len,
2334 struct file_lock *pLockData, const __u16 lock_type,
2335 const bool waitFlag)
Steve French08547b02006-02-28 22:39:25 +00002336{
2337 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2338 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French08547b02006-02-28 22:39:25 +00002339 struct cifs_posix_lock *parm_data;
2340 int rc = 0;
Steve French3a5ff612006-07-14 22:37:11 +00002341 int timeout = 0;
Steve French08547b02006-02-28 22:39:25 +00002342 int bytes_returned = 0;
Steve French133672e2007-11-13 22:41:37 +00002343 int resp_buf_type = 0;
Steve French08547b02006-02-28 22:39:25 +00002344 __u16 params, param_offset, offset, byte_count, count;
Steve French133672e2007-11-13 22:41:37 +00002345 struct kvec iov[1];
Steve French08547b02006-02-28 22:39:25 +00002346
Joe Perchesf96637b2013-05-04 22:12:25 -05002347 cifs_dbg(FYI, "Posix Lock\n");
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002348
Steve French08547b02006-02-28 22:39:25 +00002349 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2350
2351 if (rc)
2352 return rc;
2353
2354 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2355
Steve French50c2f752007-07-13 00:33:32 +00002356 params = 6;
Steve French08547b02006-02-28 22:39:25 +00002357 pSMB->MaxSetupCount = 0;
2358 pSMB->Reserved = 0;
2359 pSMB->Flags = 0;
Steve French08547b02006-02-28 22:39:25 +00002360 pSMB->Reserved2 = 0;
2361 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2362 offset = param_offset + params;
2363
Steve French08547b02006-02-28 22:39:25 +00002364 count = sizeof(struct cifs_posix_lock);
2365 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002366 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Steve French08547b02006-02-28 22:39:25 +00002367 pSMB->SetupCount = 1;
2368 pSMB->Reserved3 = 0;
Jeff Laytonc5fd3632012-07-23 13:28:37 -04002369 if (pLockData)
Steve French08547b02006-02-28 22:39:25 +00002370 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2371 else
2372 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2373 byte_count = 3 /* pad */ + params + count;
2374 pSMB->DataCount = cpu_to_le16(count);
2375 pSMB->ParameterCount = cpu_to_le16(params);
2376 pSMB->TotalDataCount = pSMB->DataCount;
2377 pSMB->TotalParameterCount = pSMB->ParameterCount;
2378 pSMB->ParameterOffset = cpu_to_le16(param_offset);
Steve French50c2f752007-07-13 00:33:32 +00002379 parm_data = (struct cifs_posix_lock *)
Steve French08547b02006-02-28 22:39:25 +00002380 (((char *) &pSMB->hdr.Protocol) + offset);
2381
2382 parm_data->lock_type = cpu_to_le16(lock_type);
Steve French790fe572007-07-07 19:25:05 +00002383 if (waitFlag) {
Steve French133672e2007-11-13 22:41:37 +00002384 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
Steve Frenchcec6815a2006-05-30 18:07:17 +00002385 parm_data->lock_flags = cpu_to_le16(1);
Steve French3a5ff612006-07-14 22:37:11 +00002386 pSMB->Timeout = cpu_to_le32(-1);
2387 } else
2388 pSMB->Timeout = 0;
2389
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04002390 parm_data->pid = cpu_to_le32(netpid);
Jeff Laytonc5fd3632012-07-23 13:28:37 -04002391 parm_data->start = cpu_to_le64(start_offset);
Steve Frenchcec6815a2006-05-30 18:07:17 +00002392 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
Steve French08547b02006-02-28 22:39:25 +00002393
2394 pSMB->DataOffset = cpu_to_le16(offset);
Steve Frenchf26282c2006-03-01 09:17:37 +00002395 pSMB->Fid = smb_file_id;
Steve French08547b02006-02-28 22:39:25 +00002396 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2397 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002398 inc_rfc1001_len(pSMB, byte_count);
Steve French08547b02006-02-28 22:39:25 +00002399 pSMB->ByteCount = cpu_to_le16(byte_count);
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002400 if (waitFlag) {
2401 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2402 (struct smb_hdr *) pSMBr, &bytes_returned);
2403 } else {
Steve French133672e2007-11-13 22:41:37 +00002404 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002405 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French133672e2007-11-13 22:41:37 +00002406 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2407 &resp_buf_type, timeout);
2408 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2409 not try to free it twice below on exit */
2410 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00002411 }
2412
Steve French08547b02006-02-28 22:39:25 +00002413 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002414 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc);
Jeff Laytonc5fd3632012-07-23 13:28:37 -04002415 } else if (pLockData) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002416 /* lock structure can be returned on get */
2417 __u16 data_offset;
2418 __u16 data_count;
2419 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French08547b02006-02-28 22:39:25 +00002420
Jeff Layton820a8032011-05-04 08:05:26 -04002421 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002422 rc = -EIO; /* bad smb */
2423 goto plk_err_exit;
2424 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002425 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2426 data_count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French790fe572007-07-07 19:25:05 +00002427 if (data_count < sizeof(struct cifs_posix_lock)) {
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002428 rc = -EIO;
2429 goto plk_err_exit;
2430 }
2431 parm_data = (struct cifs_posix_lock *)
2432 ((char *)&pSMBr->hdr.Protocol + data_offset);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002433 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002434 pLockData->fl_type = F_UNLCK;
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002435 else {
2436 if (parm_data->lock_type ==
2437 __constant_cpu_to_le16(CIFS_RDLCK))
2438 pLockData->fl_type = F_RDLCK;
2439 else if (parm_data->lock_type ==
2440 __constant_cpu_to_le16(CIFS_WRLCK))
2441 pLockData->fl_type = F_WRLCK;
2442
Steve French5443d132011-03-13 05:08:25 +00002443 pLockData->fl_start = le64_to_cpu(parm_data->start);
2444 pLockData->fl_end = pLockData->fl_start +
2445 le64_to_cpu(parm_data->length) - 1;
2446 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +04002447 }
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002448 }
Steve French50c2f752007-07-13 00:33:32 +00002449
Steve Frenchfc94cdb2006-05-30 18:03:32 +00002450plk_err_exit:
Steve French08547b02006-02-28 22:39:25 +00002451 if (pSMB)
2452 cifs_small_buf_release(pSMB);
2453
Steve French133672e2007-11-13 22:41:37 +00002454 if (resp_buf_type == CIFS_SMALL_BUFFER)
2455 cifs_small_buf_release(iov[0].iov_base);
2456 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2457 cifs_buf_release(iov[0].iov_base);
2458
Steve French08547b02006-02-28 22:39:25 +00002459 /* Note: On -EAGAIN error only caller can retry on handle based calls
2460 since file handle passed in no longer valid */
2461
2462 return rc;
2463}
2464
2465
2466int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002467CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468{
2469 int rc = 0;
2470 CLOSE_REQ *pSMB = NULL;
Joe Perchesf96637b2013-05-04 22:12:25 -05002471 cifs_dbg(FYI, "In CIFSSMBClose\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002472
2473/* do not retry on dead session on close */
2474 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
Steve French790fe572007-07-07 19:25:05 +00002475 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 return 0;
2477 if (rc)
2478 return rc;
2479
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 pSMB->FileID = (__u16) smb_file_id;
Steve Frenchb815f1e52006-10-02 05:53:29 +00002481 pSMB->LastWriteTime = 0xFFFFFFFF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04002483 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002484 cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 if (rc) {
Steve French790fe572007-07-07 19:25:05 +00002486 if (rc != -EINTR) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 /* EINTR is expected when user ctl-c to kill app */
Joe Perchesf96637b2013-05-04 22:12:25 -05002488 cifs_dbg(VFS, "Send error in Close = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 }
2490 }
2491
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 /* Since session is dead, file will be closed on server already */
Steve French790fe572007-07-07 19:25:05 +00002493 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 rc = 0;
2495
2496 return rc;
2497}
2498
2499int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002500CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
Steve Frenchb298f222009-02-21 21:17:43 +00002501{
2502 int rc = 0;
2503 FLUSH_REQ *pSMB = NULL;
Joe Perchesf96637b2013-05-04 22:12:25 -05002504 cifs_dbg(FYI, "In CIFSSMBFlush\n");
Steve Frenchb298f222009-02-21 21:17:43 +00002505
2506 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2507 if (rc)
2508 return rc;
2509
2510 pSMB->FileID = (__u16) smb_file_id;
2511 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04002512 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002513 cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
Steve Frenchb298f222009-02-21 21:17:43 +00002514 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002515 cifs_dbg(VFS, "Send error in Flush = %d\n", rc);
Steve Frenchb298f222009-02-21 21:17:43 +00002516
2517 return rc;
2518}
2519
2520int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002521CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002522 const char *from_name, const char *to_name,
2523 struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524{
2525 int rc = 0;
2526 RENAME_REQ *pSMB = NULL;
2527 RENAME_RSP *pSMBr = NULL;
2528 int bytes_returned;
2529 int name_len, name_len2;
2530 __u16 count;
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002531 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532
Joe Perchesf96637b2013-05-04 22:12:25 -05002533 cifs_dbg(FYI, "In CIFSSMBRename\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534renameRetry:
2535 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2536 (void **) &pSMBr);
2537 if (rc)
2538 return rc;
2539
2540 pSMB->BufferFormat = 0x04;
2541 pSMB->SearchAttributes =
2542 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2543 ATTR_DIRECTORY);
2544
2545 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002546 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2547 from_name, PATH_MAX,
2548 cifs_sb->local_nls, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 name_len++; /* trailing null */
2550 name_len *= 2;
2551 pSMB->OldFileName[name_len] = 0x04; /* pad */
2552 /* protocol requires ASCII signature byte on Unicode string */
2553 pSMB->OldFileName[name_len + 1] = 0x00;
2554 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06002555 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002556 to_name, PATH_MAX, cifs_sb->local_nls,
2557 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2559 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002560 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002561 name_len = strnlen(from_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 name_len++; /* trailing null */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002563 strncpy(pSMB->OldFileName, from_name, name_len);
2564 name_len2 = strnlen(to_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 name_len2++; /* trailing null */
2566 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
Pavel Shilovsky8ceb9842012-09-18 16:20:30 -07002567 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 name_len2++; /* trailing null */
2569 name_len2++; /* signature byte */
2570 }
2571
2572 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002573 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 pSMB->ByteCount = cpu_to_le16(count);
2575
2576 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2577 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002578 cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002579 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002580 cifs_dbg(FYI, "Send error in rename = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 cifs_buf_release(pSMB);
2583
2584 if (rc == -EAGAIN)
2585 goto renameRetry;
2586
2587 return rc;
2588}
2589
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002590int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
Jeff Layton391e5752008-09-24 11:32:59 -04002591 int netfid, const char *target_name,
Steve French50c2f752007-07-13 00:33:32 +00002592 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593{
2594 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2595 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
Steve French50c2f752007-07-13 00:33:32 +00002596 struct set_file_rename *rename_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 char *data_offset;
2598 char dummy_string[30];
2599 int rc = 0;
2600 int bytes_returned = 0;
2601 int len_of_str;
2602 __u16 params, param_offset, offset, count, byte_count;
2603
Joe Perchesf96637b2013-05-04 22:12:25 -05002604 cifs_dbg(FYI, "Rename to File by handle\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2606 (void **) &pSMBr);
2607 if (rc)
2608 return rc;
2609
2610 params = 6;
2611 pSMB->MaxSetupCount = 0;
2612 pSMB->Reserved = 0;
2613 pSMB->Flags = 0;
2614 pSMB->Timeout = 0;
2615 pSMB->Reserved2 = 0;
2616 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2617 offset = param_offset + params;
2618
2619 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2620 rename_info = (struct set_file_rename *) data_offset;
2621 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve Frenchad7a2922008-02-07 23:25:02 +00002622 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 pSMB->SetupCount = 1;
2624 pSMB->Reserved3 = 0;
2625 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2626 byte_count = 3 /* pad */ + params;
2627 pSMB->ParameterCount = cpu_to_le16(params);
2628 pSMB->TotalParameterCount = pSMB->ParameterCount;
2629 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2630 pSMB->DataOffset = cpu_to_le16(offset);
2631 /* construct random name ".cifs_tmp<inodenum><mid>" */
2632 rename_info->overwrite = cpu_to_le32(1);
2633 rename_info->root_fid = 0;
2634 /* unicode only call */
Steve French790fe572007-07-07 19:25:05 +00002635 if (target_name == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00002636 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
Steve Frenchacbbb762012-01-18 22:32:33 -06002637 len_of_str =
2638 cifsConvertToUTF16((__le16 *)rename_info->target_name,
Steve French737b7582005-04-28 22:41:06 -07002639 dummy_string, 24, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 } else {
Steve Frenchacbbb762012-01-18 22:32:33 -06002641 len_of_str =
2642 cifsConvertToUTF16((__le16 *)rename_info->target_name,
Steve French50c2f752007-07-13 00:33:32 +00002643 target_name, PATH_MAX, nls_codepage,
2644 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 }
2646 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
Jeff Layton391e5752008-09-24 11:32:59 -04002647 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648 byte_count += count;
2649 pSMB->DataCount = cpu_to_le16(count);
2650 pSMB->TotalDataCount = pSMB->DataCount;
2651 pSMB->Fid = netfid;
2652 pSMB->InformationLevel =
2653 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2654 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002655 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 pSMB->ByteCount = cpu_to_le16(byte_count);
2657 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00002658 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002659 cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
Steve Frenchad7a2922008-02-07 23:25:02 +00002660 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002661 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n",
2662 rc);
Steve Frencha5a2b482005-08-20 21:42:53 -07002663
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 cifs_buf_release(pSMB);
2665
2666 /* Note: On -EAGAIN error only caller can retry on handle based calls
2667 since file handle passed in no longer valid */
2668
2669 return rc;
2670}
2671
2672int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002673CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
2674 const char *fromName, const __u16 target_tid, const char *toName,
2675 const int flags, const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002676{
2677 int rc = 0;
2678 COPY_REQ *pSMB = NULL;
2679 COPY_RSP *pSMBr = NULL;
2680 int bytes_returned;
2681 int name_len, name_len2;
2682 __u16 count;
2683
Joe Perchesf96637b2013-05-04 22:12:25 -05002684 cifs_dbg(FYI, "In CIFSSMBCopy\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685copyRetry:
2686 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2687 (void **) &pSMBr);
2688 if (rc)
2689 return rc;
2690
2691 pSMB->BufferFormat = 0x04;
2692 pSMB->Tid2 = target_tid;
2693
2694 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2695
2696 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -06002697 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2698 fromName, PATH_MAX, nls_codepage,
2699 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 name_len++; /* trailing null */
2701 name_len *= 2;
2702 pSMB->OldFileName[name_len] = 0x04; /* pad */
2703 /* protocol requires ASCII signature byte on Unicode string */
2704 pSMB->OldFileName[name_len + 1] = 0x00;
Steve French50c2f752007-07-13 00:33:32 +00002705 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06002706 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2707 toName, PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2709 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002710 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711 name_len = strnlen(fromName, PATH_MAX);
2712 name_len++; /* trailing null */
2713 strncpy(pSMB->OldFileName, fromName, name_len);
2714 name_len2 = strnlen(toName, PATH_MAX);
2715 name_len2++; /* trailing null */
2716 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2717 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2718 name_len2++; /* trailing null */
2719 name_len2++; /* signature byte */
2720 }
2721
2722 count = 1 /* 1st signature byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002723 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724 pSMB->ByteCount = cpu_to_le16(count);
2725
2726 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2727 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2728 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002729 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n",
2730 rc, le16_to_cpu(pSMBr->CopyCount));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 }
Steve French0d817bc2008-05-22 02:02:03 +00002732 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733
2734 if (rc == -EAGAIN)
2735 goto copyRetry;
2736
2737 return rc;
2738}
2739
2740int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002741CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 const char *fromName, const char *toName,
2743 const struct nls_table *nls_codepage)
2744{
2745 TRANSACTION2_SPI_REQ *pSMB = NULL;
2746 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2747 char *data_offset;
2748 int name_len;
2749 int name_len_target;
2750 int rc = 0;
2751 int bytes_returned = 0;
2752 __u16 params, param_offset, offset, byte_count;
2753
Joe Perchesf96637b2013-05-04 22:12:25 -05002754 cifs_dbg(FYI, "In Symlink Unix style\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755createSymLinkRetry:
2756 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2757 (void **) &pSMBr);
2758 if (rc)
2759 return rc;
2760
2761 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2762 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06002763 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2764 /* find define for this maxpathcomponent */
2765 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 name_len++; /* trailing null */
2767 name_len *= 2;
2768
Steve French50c2f752007-07-13 00:33:32 +00002769 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 name_len = strnlen(fromName, PATH_MAX);
2771 name_len++; /* trailing null */
2772 strncpy(pSMB->FileName, fromName, name_len);
2773 }
2774 params = 6 + name_len;
2775 pSMB->MaxSetupCount = 0;
2776 pSMB->Reserved = 0;
2777 pSMB->Flags = 0;
2778 pSMB->Timeout = 0;
2779 pSMB->Reserved2 = 0;
2780 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002781 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 offset = param_offset + params;
2783
2784 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2785 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2786 name_len_target =
Steve Frenchacbbb762012-01-18 22:32:33 -06002787 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2788 /* find define for this maxpathcomponent */
2789 , nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 name_len_target++; /* trailing null */
2791 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00002792 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793 name_len_target = strnlen(toName, PATH_MAX);
2794 name_len_target++; /* trailing null */
2795 strncpy(data_offset, toName, name_len_target);
2796 }
2797
2798 pSMB->MaxParameterCount = cpu_to_le16(2);
2799 /* BB find exact max on data count below from sess */
2800 pSMB->MaxDataCount = cpu_to_le16(1000);
2801 pSMB->SetupCount = 1;
2802 pSMB->Reserved3 = 0;
2803 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2804 byte_count = 3 /* pad */ + params + name_len_target;
2805 pSMB->DataCount = cpu_to_le16(name_len_target);
2806 pSMB->ParameterCount = cpu_to_le16(params);
2807 pSMB->TotalDataCount = pSMB->DataCount;
2808 pSMB->TotalParameterCount = pSMB->ParameterCount;
2809 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2810 pSMB->DataOffset = cpu_to_le16(offset);
2811 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2812 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002813 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 pSMB->ByteCount = cpu_to_le16(byte_count);
2815 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2816 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002817 cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002818 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002819 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n",
2820 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
Steve French0d817bc2008-05-22 02:02:03 +00002822 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823
2824 if (rc == -EAGAIN)
2825 goto createSymLinkRetry;
2826
2827 return rc;
2828}
2829
2830int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002831CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 const char *fromName, const char *toName,
Steve French737b7582005-04-28 22:41:06 -07002833 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834{
2835 TRANSACTION2_SPI_REQ *pSMB = NULL;
2836 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2837 char *data_offset;
2838 int name_len;
2839 int name_len_target;
2840 int rc = 0;
2841 int bytes_returned = 0;
2842 __u16 params, param_offset, offset, byte_count;
2843
Joe Perchesf96637b2013-05-04 22:12:25 -05002844 cifs_dbg(FYI, "In Create Hard link Unix style\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845createHardLinkRetry:
2846 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2847 (void **) &pSMBr);
2848 if (rc)
2849 return rc;
2850
2851 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Steve Frenchacbbb762012-01-18 22:32:33 -06002852 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2853 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 name_len++; /* trailing null */
2855 name_len *= 2;
2856
Steve French50c2f752007-07-13 00:33:32 +00002857 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 name_len = strnlen(toName, PATH_MAX);
2859 name_len++; /* trailing null */
2860 strncpy(pSMB->FileName, toName, name_len);
2861 }
2862 params = 6 + name_len;
2863 pSMB->MaxSetupCount = 0;
2864 pSMB->Reserved = 0;
2865 pSMB->Flags = 0;
2866 pSMB->Timeout = 0;
2867 pSMB->Reserved2 = 0;
2868 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00002869 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870 offset = param_offset + params;
2871
2872 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2873 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2874 name_len_target =
Steve Frenchacbbb762012-01-18 22:32:33 -06002875 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2876 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 name_len_target++; /* trailing null */
2878 name_len_target *= 2;
Steve French50c2f752007-07-13 00:33:32 +00002879 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 name_len_target = strnlen(fromName, PATH_MAX);
2881 name_len_target++; /* trailing null */
2882 strncpy(data_offset, fromName, name_len_target);
2883 }
2884
2885 pSMB->MaxParameterCount = cpu_to_le16(2);
2886 /* BB find exact max on data count below from sess*/
2887 pSMB->MaxDataCount = cpu_to_le16(1000);
2888 pSMB->SetupCount = 1;
2889 pSMB->Reserved3 = 0;
2890 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2891 byte_count = 3 /* pad */ + params + name_len_target;
2892 pSMB->ParameterCount = cpu_to_le16(params);
2893 pSMB->TotalParameterCount = pSMB->ParameterCount;
2894 pSMB->DataCount = cpu_to_le16(name_len_target);
2895 pSMB->TotalDataCount = pSMB->DataCount;
2896 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2897 pSMB->DataOffset = cpu_to_le16(offset);
2898 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2899 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002900 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 pSMB->ByteCount = cpu_to_le16(byte_count);
2902 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2903 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002904 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002905 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002906 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n",
2907 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908
2909 cifs_buf_release(pSMB);
2910 if (rc == -EAGAIN)
2911 goto createHardLinkRetry;
2912
2913 return rc;
2914}
2915
2916int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002917CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
Steve Frenchd6e906f2012-09-18 16:20:31 -07002918 const char *from_name, const char *to_name,
2919 struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920{
2921 int rc = 0;
2922 NT_RENAME_REQ *pSMB = NULL;
2923 RENAME_RSP *pSMBr = NULL;
2924 int bytes_returned;
2925 int name_len, name_len2;
2926 __u16 count;
Steve Frenchd6e906f2012-09-18 16:20:31 -07002927 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928
Joe Perchesf96637b2013-05-04 22:12:25 -05002929 cifs_dbg(FYI, "In CIFSCreateHardLink\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930winCreateHardLinkRetry:
2931
2932 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2933 (void **) &pSMBr);
2934 if (rc)
2935 return rc;
2936
2937 pSMB->SearchAttributes =
2938 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2939 ATTR_DIRECTORY);
2940 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2941 pSMB->ClusterCount = 0;
2942
2943 pSMB->BufferFormat = 0x04;
2944
2945 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2946 name_len =
Steve Frenchd6e906f2012-09-18 16:20:31 -07002947 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
2948 PATH_MAX, cifs_sb->local_nls, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 name_len++; /* trailing null */
2950 name_len *= 2;
Jeff Laytonfcc7c092009-02-28 12:59:03 -05002951
2952 /* protocol specifies ASCII buffer format (0x04) for unicode */
2953 pSMB->OldFileName[name_len] = 0x04;
2954 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955 name_len2 =
Steve Frenchacbbb762012-01-18 22:32:33 -06002956 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
Steve Frenchd6e906f2012-09-18 16:20:31 -07002957 to_name, PATH_MAX, cifs_sb->local_nls,
2958 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2960 name_len2 *= 2; /* convert to bytes */
Steve French50c2f752007-07-13 00:33:32 +00002961 } else { /* BB improve the check for buffer overruns BB */
Steve Frenchd6e906f2012-09-18 16:20:31 -07002962 name_len = strnlen(from_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 name_len++; /* trailing null */
Steve Frenchd6e906f2012-09-18 16:20:31 -07002964 strncpy(pSMB->OldFileName, from_name, name_len);
2965 name_len2 = strnlen(to_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 name_len2++; /* trailing null */
2967 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
Steve Frenchd6e906f2012-09-18 16:20:31 -07002968 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 name_len2++; /* trailing null */
2970 name_len2++; /* signature byte */
2971 }
2972
2973 count = 1 /* string type byte */ + name_len + name_len2;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002974 inc_rfc1001_len(pSMB, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 pSMB->ByteCount = cpu_to_le16(count);
2976
2977 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2978 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04002979 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
Steve Frenchad7a2922008-02-07 23:25:02 +00002980 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002981 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00002982
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 cifs_buf_release(pSMB);
2984 if (rc == -EAGAIN)
2985 goto winCreateHardLinkRetry;
2986
2987 return rc;
2988}
2989
2990int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002991CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton460b9692009-04-30 07:17:56 -04002992 const unsigned char *searchName, char **symlinkinfo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 const struct nls_table *nls_codepage)
2994{
2995/* SMB_QUERY_FILE_UNIX_LINK */
2996 TRANSACTION2_QPI_REQ *pSMB = NULL;
2997 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2998 int rc = 0;
2999 int bytes_returned;
3000 int name_len;
3001 __u16 params, byte_count;
Jeff Layton460b9692009-04-30 07:17:56 -04003002 char *data_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003
Joe Perchesf96637b2013-05-04 22:12:25 -05003004 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005
3006querySymLinkRetry:
3007 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3008 (void **) &pSMBr);
3009 if (rc)
3010 return rc;
3011
3012 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3013 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003014 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3015 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 name_len++; /* trailing null */
3017 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003018 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 name_len = strnlen(searchName, PATH_MAX);
3020 name_len++; /* trailing null */
3021 strncpy(pSMB->FileName, searchName, name_len);
3022 }
3023
3024 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3025 pSMB->TotalDataCount = 0;
3026 pSMB->MaxParameterCount = cpu_to_le16(2);
Jeff Layton46a75742009-05-24 18:45:17 -04003027 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 pSMB->MaxSetupCount = 0;
3029 pSMB->Reserved = 0;
3030 pSMB->Flags = 0;
3031 pSMB->Timeout = 0;
3032 pSMB->Reserved2 = 0;
3033 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00003034 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 pSMB->DataCount = 0;
3036 pSMB->DataOffset = 0;
3037 pSMB->SetupCount = 1;
3038 pSMB->Reserved3 = 0;
3039 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3040 byte_count = params + 1 /* pad */ ;
3041 pSMB->TotalParameterCount = cpu_to_le16(params);
3042 pSMB->ParameterCount = pSMB->TotalParameterCount;
3043 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3044 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003045 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 pSMB->ByteCount = cpu_to_le16(byte_count);
3047
3048 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3049 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3050 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003051 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052 } else {
3053 /* decode response */
3054
3055 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003057 if (rc || get_bcc(&pSMBr->hdr) < 2)
Jeff Layton460b9692009-04-30 07:17:56 -04003058 rc = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059 else {
Steve French0e0d2cf2009-05-01 05:27:32 +00003060 bool is_unicode;
Jeff Layton460b9692009-04-30 07:17:56 -04003061 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062
Jeff Layton460b9692009-04-30 07:17:56 -04003063 data_start = ((char *) &pSMBr->hdr.Protocol) +
3064 le16_to_cpu(pSMBr->t2.DataOffset);
3065
Steve French0e0d2cf2009-05-01 05:27:32 +00003066 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3067 is_unicode = true;
3068 else
3069 is_unicode = false;
3070
Steve French737b7582005-04-28 22:41:06 -07003071 /* BB FIXME investigate remapping reserved chars here */
Steve Frenchacbbb762012-01-18 22:32:33 -06003072 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3073 count, is_unicode, nls_codepage);
Jeff Layton8b6427a2009-05-19 09:57:03 -04003074 if (!*symlinkinfo)
Jeff Layton460b9692009-04-30 07:17:56 -04003075 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076 }
3077 }
3078 cifs_buf_release(pSMB);
3079 if (rc == -EAGAIN)
3080 goto querySymLinkRetry;
3081 return rc;
3082}
3083
Steve Frenchc52a9552011-02-24 06:16:22 +00003084/*
3085 * Recent Windows versions now create symlinks more frequently
3086 * and they use the "reparse point" mechanism below. We can of course
3087 * do symlinks nicely to Samba and other servers which support the
3088 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3089 * "MF" symlinks optionally, but for recent Windows we really need to
3090 * reenable the code below and fix the cifs_symlink callers to handle this.
3091 * In the interim this code has been moved to its own config option so
3092 * it is not compiled in by default until callers fixed up and more tested.
3093 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094int
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003095CIFSSMBQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3096 __u16 fid, char **symlinkinfo,
3097 const struct nls_table *nls_codepage)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098{
3099 int rc = 0;
3100 int bytes_returned;
Steve French50c2f752007-07-13 00:33:32 +00003101 struct smb_com_transaction_ioctl_req *pSMB;
3102 struct smb_com_transaction_ioctl_rsp *pSMBr;
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003103 bool is_unicode;
3104 unsigned int sub_len;
3105 char *sub_start;
Steve Frenchc31f3302013-09-28 18:24:12 -05003106 struct reparse_symlink_data *reparse_buf;
3107 struct reparse_posix_data *posix_buf;
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003108 __u32 data_offset, data_count;
3109 char *end_of_smb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003111 cifs_dbg(FYI, "In Windows reparse style QueryLink for fid %u\n", fid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3113 (void **) &pSMBr);
3114 if (rc)
3115 return rc;
3116
3117 pSMB->TotalParameterCount = 0 ;
3118 pSMB->TotalDataCount = 0;
3119 pSMB->MaxParameterCount = cpu_to_le32(2);
3120 /* BB find exact data count max from sess structure BB */
Jeff Laytonc974bef2011-10-11 06:41:32 -04003121 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 pSMB->MaxSetupCount = 4;
3123 pSMB->Reserved = 0;
3124 pSMB->ParameterOffset = 0;
3125 pSMB->DataCount = 0;
3126 pSMB->DataOffset = 0;
3127 pSMB->SetupCount = 4;
3128 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3129 pSMB->ParameterCount = pSMB->TotalParameterCount;
3130 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3131 pSMB->IsFsctl = 1; /* FSCTL */
3132 pSMB->IsRootFlag = 0;
3133 pSMB->Fid = fid; /* file handle always le */
3134 pSMB->ByteCount = 0;
3135
3136 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3137 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3138 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003139 cifs_dbg(FYI, "Send error in QueryReparseLinkInfo = %d\n", rc);
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003140 goto qreparse_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141 }
Steve French989c7e52009-05-02 05:32:20 +00003142
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003143 data_offset = le32_to_cpu(pSMBr->DataOffset);
3144 data_count = le32_to_cpu(pSMBr->DataCount);
3145 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3146 /* BB also check enough total bytes returned */
3147 rc = -EIO; /* bad smb */
3148 goto qreparse_out;
3149 }
3150 if (!data_count || (data_count > 2048)) {
3151 rc = -EIO;
3152 cifs_dbg(FYI, "Invalid return data count on get reparse info ioctl\n");
3153 goto qreparse_out;
3154 }
3155 end_of_smb = 2 + get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
Steve Frenchc31f3302013-09-28 18:24:12 -05003156 reparse_buf = (struct reparse_symlink_data *)
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003157 ((char *)&pSMBr->hdr.Protocol + data_offset);
3158 if ((char *)reparse_buf >= end_of_smb) {
3159 rc = -EIO;
3160 goto qreparse_out;
3161 }
Steve Frenchc31f3302013-09-28 18:24:12 -05003162 if (reparse_buf->ReparseTag == cpu_to_le32(IO_REPARSE_TAG_NFS)) {
3163 cifs_dbg(FYI, "NFS style reparse tag\n");
3164 posix_buf = (struct reparse_posix_data *)reparse_buf;
3165
3166 if (posix_buf->InodeType != cpu_to_le64(NFS_SPECFILE_LNK)) {
3167 cifs_dbg(FYI, "unsupported file type 0x%llx\n",
3168 le64_to_cpu(posix_buf->InodeType));
3169 rc = -EOPNOTSUPP;
3170 goto qreparse_out;
3171 }
3172 is_unicode = true;
3173 sub_len = le16_to_cpu(reparse_buf->ReparseDataLength);
3174 if (posix_buf->PathBuffer + sub_len > end_of_smb) {
3175 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3176 rc = -EIO;
3177 goto qreparse_out;
3178 }
3179 *symlinkinfo = cifs_strndup_from_utf16(posix_buf->PathBuffer,
3180 sub_len, is_unicode, nls_codepage);
3181 goto qreparse_out;
3182 } else if (reparse_buf->ReparseTag !=
3183 cpu_to_le32(IO_REPARSE_TAG_SYMLINK)) {
3184 rc = -EOPNOTSUPP;
3185 goto qreparse_out;
3186 }
3187
3188 /* Reparse tag is NTFS symlink */
3189 sub_start = le16_to_cpu(reparse_buf->SubstituteNameOffset) +
3190 reparse_buf->PathBuffer;
3191 sub_len = le16_to_cpu(reparse_buf->SubstituteNameLength);
3192 if (sub_start + sub_len > end_of_smb) {
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003193 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3194 rc = -EIO;
3195 goto qreparse_out;
3196 }
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003197 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3198 is_unicode = true;
3199 else
3200 is_unicode = false;
3201
3202 /* BB FIXME investigate remapping reserved chars here */
3203 *symlinkinfo = cifs_strndup_from_utf16(sub_start, sub_len, is_unicode,
3204 nls_codepage);
3205 if (!*symlinkinfo)
3206 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207qreparse_out:
Steve French4a6d87f2005-08-13 08:15:54 -07003208 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209
Pavel Shilovskyd244bf22013-08-14 19:25:22 +04003210 /*
3211 * Note: On -EAGAIN error only caller can retry on handle based calls
3212 * since file handle passed in no longer valid.
3213 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 return rc;
3215}
3216
Steve Frenchc7f508a2013-10-14 15:27:32 -05003217int
3218CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
3219 __u16 fid)
3220{
3221 int rc = 0;
3222 int bytes_returned;
3223 struct smb_com_transaction_compr_ioctl_req *pSMB;
3224 struct smb_com_transaction_ioctl_rsp *pSMBr;
3225
3226 cifs_dbg(FYI, "Set compression for %u\n", fid);
3227 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3228 (void **) &pSMBr);
3229 if (rc)
3230 return rc;
3231
3232 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT);
3233
3234 pSMB->TotalParameterCount = 0;
3235 pSMB->TotalDataCount = __constant_cpu_to_le32(2);
3236 pSMB->MaxParameterCount = 0;
3237 pSMB->MaxDataCount = 0;
3238 pSMB->MaxSetupCount = 4;
3239 pSMB->Reserved = 0;
3240 pSMB->ParameterOffset = 0;
3241 pSMB->DataCount = __constant_cpu_to_le32(2);
3242 pSMB->DataOffset =
3243 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req,
3244 compression_state) - 4); /* 84 */
3245 pSMB->SetupCount = 4;
3246 pSMB->SubCommand = __constant_cpu_to_le16(NT_TRANSACT_IOCTL);
3247 pSMB->ParameterCount = 0;
3248 pSMB->FunctionCode = __constant_cpu_to_le32(FSCTL_SET_COMPRESSION);
3249 pSMB->IsFsctl = 1; /* FSCTL */
3250 pSMB->IsRootFlag = 0;
3251 pSMB->Fid = fid; /* file handle always le */
3252 /* 3 byte pad, followed by 2 byte compress state */
3253 pSMB->ByteCount = __constant_cpu_to_le16(5);
3254 inc_rfc1001_len(pSMB, 5);
3255
3256 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3257 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3258 if (rc)
3259 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc);
3260
3261 cifs_buf_release(pSMB);
3262
3263 /*
3264 * Note: On -EAGAIN error only caller can retry on handle based calls
3265 * since file handle passed in no longer valid.
3266 */
3267 return rc;
3268}
3269
3270
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271#ifdef CONFIG_CIFS_POSIX
3272
3273/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
Steve French50c2f752007-07-13 00:33:32 +00003274static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3275 struct cifs_posix_ace *cifs_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276{
3277 /* u8 cifs fields do not need le conversion */
Steve Frenchff7feac2005-11-15 16:45:16 -08003278 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3279 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3280 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
Joe Perchesf96637b2013-05-04 22:12:25 -05003281/*
3282 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3283 ace->e_perm, ace->e_tag, ace->e_id);
3284*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285
3286 return;
3287}
3288
3289/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
Steve French50c2f752007-07-13 00:33:32 +00003290static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3291 const int acl_type, const int size_of_data_area)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292{
3293 int size = 0;
3294 int i;
3295 __u16 count;
Steve French50c2f752007-07-13 00:33:32 +00003296 struct cifs_posix_ace *pACE;
3297 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3298 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003299
3300 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3301 return -EOPNOTSUPP;
3302
Steve French790fe572007-07-07 19:25:05 +00003303 if (acl_type & ACL_TYPE_ACCESS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003304 count = le16_to_cpu(cifs_acl->access_entry_count);
3305 pACE = &cifs_acl->ace_array[0];
3306 size = sizeof(struct cifs_posix_acl);
3307 size += sizeof(struct cifs_posix_ace) * count;
3308 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003309 if (size_of_data_area < size) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003310 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
3311 size_of_data_area, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 return -EINVAL;
3313 }
Steve French790fe572007-07-07 19:25:05 +00003314 } else if (acl_type & ACL_TYPE_DEFAULT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 count = le16_to_cpu(cifs_acl->access_entry_count);
3316 size = sizeof(struct cifs_posix_acl);
3317 size += sizeof(struct cifs_posix_ace) * count;
3318/* skip past access ACEs to get to default ACEs */
3319 pACE = &cifs_acl->ace_array[count];
3320 count = le16_to_cpu(cifs_acl->default_entry_count);
3321 size += sizeof(struct cifs_posix_ace) * count;
3322 /* check if we would go beyond end of SMB */
Steve French790fe572007-07-07 19:25:05 +00003323 if (size_of_data_area < size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003324 return -EINVAL;
3325 } else {
3326 /* illegal type */
3327 return -EINVAL;
3328 }
3329
3330 size = posix_acl_xattr_size(count);
Steve French790fe572007-07-07 19:25:05 +00003331 if ((buflen == 0) || (local_acl == NULL)) {
Steve French50c2f752007-07-13 00:33:32 +00003332 /* used to query ACL EA size */
Steve French790fe572007-07-07 19:25:05 +00003333 } else if (size > buflen) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334 return -ERANGE;
3335 } else /* buffer big enough */ {
Steve Frenchff7feac2005-11-15 16:45:16 -08003336 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
Steve French50c2f752007-07-13 00:33:32 +00003337 for (i = 0; i < count ; i++) {
3338 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3339 pACE++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340 }
3341 }
3342 return size;
3343}
3344
Steve French50c2f752007-07-13 00:33:32 +00003345static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3346 const posix_acl_xattr_entry *local_ace)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347{
3348 __u16 rc = 0; /* 0 = ACL converted ok */
3349
Steve Frenchff7feac2005-11-15 16:45:16 -08003350 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3351 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003352 /* BB is there a better way to handle the large uid? */
Steve French790fe572007-07-07 19:25:05 +00003353 if (local_ace->e_id == cpu_to_le32(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 /* Probably no need to le convert -1 on any arch but can not hurt */
3355 cifs_ace->cifs_uid = cpu_to_le64(-1);
Steve French50c2f752007-07-13 00:33:32 +00003356 } else
Steve Frenchff7feac2005-11-15 16:45:16 -08003357 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
Joe Perchesf96637b2013-05-04 22:12:25 -05003358/*
3359 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3360 ace->e_perm, ace->e_tag, ace->e_id);
3361*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362 return rc;
3363}
3364
3365/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
Steve French50c2f752007-07-13 00:33:32 +00003366static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3367 const int buflen, const int acl_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003368{
3369 __u16 rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00003370 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3371 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372 int count;
3373 int i;
3374
Steve French790fe572007-07-07 19:25:05 +00003375 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003376 return 0;
3377
3378 count = posix_acl_xattr_count((size_t)buflen);
Joe Perchesf96637b2013-05-04 22:12:25 -05003379 cifs_dbg(FYI, "setting acl with %d entries from buf of length %d and version of %d\n",
3380 count, buflen, le32_to_cpu(local_acl->a_version));
Steve French790fe572007-07-07 19:25:05 +00003381 if (le32_to_cpu(local_acl->a_version) != 2) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003382 cifs_dbg(FYI, "unknown POSIX ACL version %d\n",
3383 le32_to_cpu(local_acl->a_version));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 return 0;
3385 }
3386 cifs_acl->version = cpu_to_le16(1);
Steve Frenchb1d93352013-11-15 20:41:32 -06003387 if (acl_type == ACL_TYPE_ACCESS) {
Steve Frenchff7feac2005-11-15 16:45:16 -08003388 cifs_acl->access_entry_count = cpu_to_le16(count);
Steve Frenchb1d93352013-11-15 20:41:32 -06003389 cifs_acl->default_entry_count = __constant_cpu_to_le16(0xFFFF);
3390 } else if (acl_type == ACL_TYPE_DEFAULT) {
Steve Frenchff7feac2005-11-15 16:45:16 -08003391 cifs_acl->default_entry_count = cpu_to_le16(count);
Steve Frenchb1d93352013-11-15 20:41:32 -06003392 cifs_acl->access_entry_count = __constant_cpu_to_le16(0xFFFF);
3393 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003394 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 return 0;
3396 }
Steve French50c2f752007-07-13 00:33:32 +00003397 for (i = 0; i < count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3399 &local_acl->a_entries[i]);
Steve French790fe572007-07-07 19:25:05 +00003400 if (rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401 /* ACE not converted */
3402 break;
3403 }
3404 }
Steve French790fe572007-07-07 19:25:05 +00003405 if (rc == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3407 rc += sizeof(struct cifs_posix_acl);
3408 /* BB add check to make sure ACL does not overflow SMB */
3409 }
3410 return rc;
3411}
3412
3413int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003414CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003415 const unsigned char *searchName,
3416 char *acl_inf, const int buflen, const int acl_type,
3417 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418{
3419/* SMB_QUERY_POSIX_ACL */
3420 TRANSACTION2_QPI_REQ *pSMB = NULL;
3421 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3422 int rc = 0;
3423 int bytes_returned;
3424 int name_len;
3425 __u16 params, byte_count;
Steve French50c2f752007-07-13 00:33:32 +00003426
Joe Perchesf96637b2013-05-04 22:12:25 -05003427 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428
3429queryAclRetry:
3430 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3431 (void **) &pSMBr);
3432 if (rc)
3433 return rc;
Steve French50c2f752007-07-13 00:33:32 +00003434
Linus Torvalds1da177e2005-04-16 15:20:36 -07003435 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3436 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003437 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3438 searchName, PATH_MAX, nls_codepage,
3439 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440 name_len++; /* trailing null */
3441 name_len *= 2;
3442 pSMB->FileName[name_len] = 0;
3443 pSMB->FileName[name_len+1] = 0;
Steve French50c2f752007-07-13 00:33:32 +00003444 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003445 name_len = strnlen(searchName, PATH_MAX);
3446 name_len++; /* trailing null */
3447 strncpy(pSMB->FileName, searchName, name_len);
3448 }
3449
3450 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3451 pSMB->TotalDataCount = 0;
3452 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French50c2f752007-07-13 00:33:32 +00003453 /* BB find exact max data count below from sess structure BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454 pSMB->MaxDataCount = cpu_to_le16(4000);
3455 pSMB->MaxSetupCount = 0;
3456 pSMB->Reserved = 0;
3457 pSMB->Flags = 0;
3458 pSMB->Timeout = 0;
3459 pSMB->Reserved2 = 0;
3460 pSMB->ParameterOffset = cpu_to_le16(
Steve French50c2f752007-07-13 00:33:32 +00003461 offsetof(struct smb_com_transaction2_qpi_req,
3462 InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 pSMB->DataCount = 0;
3464 pSMB->DataOffset = 0;
3465 pSMB->SetupCount = 1;
3466 pSMB->Reserved3 = 0;
3467 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3468 byte_count = params + 1 /* pad */ ;
3469 pSMB->TotalParameterCount = cpu_to_le16(params);
3470 pSMB->ParameterCount = pSMB->TotalParameterCount;
3471 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3472 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003473 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 pSMB->ByteCount = cpu_to_le16(byte_count);
3475
3476 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3477 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04003478 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003480 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481 } else {
3482 /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00003483
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003486 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 rc = -EIO; /* bad smb */
3488 else {
3489 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3490 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3491 rc = cifs_copy_posix_acl(acl_inf,
3492 (char *)&pSMBr->hdr.Protocol+data_offset,
Steve French50c2f752007-07-13 00:33:32 +00003493 buflen, acl_type, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494 }
3495 }
3496 cifs_buf_release(pSMB);
3497 if (rc == -EAGAIN)
3498 goto queryAclRetry;
3499 return rc;
3500}
3501
3502int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003503CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00003504 const unsigned char *fileName,
3505 const char *local_acl, const int buflen,
3506 const int acl_type,
3507 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508{
3509 struct smb_com_transaction2_spi_req *pSMB = NULL;
3510 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3511 char *parm_data;
3512 int name_len;
3513 int rc = 0;
3514 int bytes_returned = 0;
3515 __u16 params, byte_count, data_count, param_offset, offset;
3516
Joe Perchesf96637b2013-05-04 22:12:25 -05003517 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003518setAclRetry:
3519 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003520 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521 if (rc)
3522 return rc;
3523 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3524 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003525 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3526 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003527 name_len++; /* trailing null */
3528 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003529 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 name_len = strnlen(fileName, PATH_MAX);
3531 name_len++; /* trailing null */
3532 strncpy(pSMB->FileName, fileName, name_len);
3533 }
3534 params = 6 + name_len;
3535 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00003536 /* BB find max SMB size from sess */
3537 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003538 pSMB->MaxSetupCount = 0;
3539 pSMB->Reserved = 0;
3540 pSMB->Flags = 0;
3541 pSMB->Timeout = 0;
3542 pSMB->Reserved2 = 0;
3543 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00003544 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 offset = param_offset + params;
3546 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3547 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3548
3549 /* convert to on the wire format for POSIX ACL */
Steve French50c2f752007-07-13 00:33:32 +00003550 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551
Steve French790fe572007-07-07 19:25:05 +00003552 if (data_count == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553 rc = -EOPNOTSUPP;
3554 goto setACLerrorExit;
3555 }
3556 pSMB->DataOffset = cpu_to_le16(offset);
3557 pSMB->SetupCount = 1;
3558 pSMB->Reserved3 = 0;
3559 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3560 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3561 byte_count = 3 /* pad */ + params + data_count;
3562 pSMB->DataCount = cpu_to_le16(data_count);
3563 pSMB->TotalDataCount = pSMB->DataCount;
3564 pSMB->ParameterCount = cpu_to_le16(params);
3565 pSMB->TotalParameterCount = pSMB->ParameterCount;
3566 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003567 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003568 pSMB->ByteCount = cpu_to_le16(byte_count);
3569 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003570 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00003571 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003572 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573
3574setACLerrorExit:
3575 cifs_buf_release(pSMB);
3576 if (rc == -EAGAIN)
3577 goto setAclRetry;
3578 return rc;
3579}
3580
Steve Frenchf654bac2005-04-28 22:41:04 -07003581/* BB fix tabs in this function FIXME BB */
3582int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003583CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
Steve Frenchad7a2922008-02-07 23:25:02 +00003584 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
Steve Frenchf654bac2005-04-28 22:41:04 -07003585{
Steve French50c2f752007-07-13 00:33:32 +00003586 int rc = 0;
3587 struct smb_t2_qfi_req *pSMB = NULL;
3588 struct smb_t2_qfi_rsp *pSMBr = NULL;
3589 int bytes_returned;
3590 __u16 params, byte_count;
Steve Frenchf654bac2005-04-28 22:41:04 -07003591
Joe Perchesf96637b2013-05-04 22:12:25 -05003592 cifs_dbg(FYI, "In GetExtAttr\n");
Steve French790fe572007-07-07 19:25:05 +00003593 if (tcon == NULL)
3594 return -ENODEV;
Steve Frenchf654bac2005-04-28 22:41:04 -07003595
3596GetExtAttrRetry:
Steve French790fe572007-07-07 19:25:05 +00003597 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3598 (void **) &pSMBr);
3599 if (rc)
3600 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003601
Steve Frenchad7a2922008-02-07 23:25:02 +00003602 params = 2 /* level */ + 2 /* fid */;
Steve French790fe572007-07-07 19:25:05 +00003603 pSMB->t2.TotalDataCount = 0;
3604 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3605 /* BB find exact max data count below from sess structure BB */
3606 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3607 pSMB->t2.MaxSetupCount = 0;
3608 pSMB->t2.Reserved = 0;
3609 pSMB->t2.Flags = 0;
3610 pSMB->t2.Timeout = 0;
3611 pSMB->t2.Reserved2 = 0;
3612 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3613 Fid) - 4);
3614 pSMB->t2.DataCount = 0;
3615 pSMB->t2.DataOffset = 0;
3616 pSMB->t2.SetupCount = 1;
3617 pSMB->t2.Reserved3 = 0;
3618 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3619 byte_count = params + 1 /* pad */ ;
3620 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3621 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3622 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3623 pSMB->Pad = 0;
Steve Frenchf654bac2005-04-28 22:41:04 -07003624 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003625 inc_rfc1001_len(pSMB, byte_count);
Steve French790fe572007-07-07 19:25:05 +00003626 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
Steve Frenchf654bac2005-04-28 22:41:04 -07003627
Steve French790fe572007-07-07 19:25:05 +00003628 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3629 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3630 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003631 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
Steve French790fe572007-07-07 19:25:05 +00003632 } else {
3633 /* decode response */
3634 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00003635 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04003636 if (rc || get_bcc(&pSMBr->hdr) < 2)
Steve French790fe572007-07-07 19:25:05 +00003637 /* If rc should we check for EOPNOSUPP and
3638 disable the srvino flag? or in caller? */
3639 rc = -EIO; /* bad smb */
3640 else {
3641 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3642 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3643 struct file_chattr_info *pfinfo;
3644 /* BB Do we need a cast or hash here ? */
3645 if (count != 16) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003646 cifs_dbg(FYI, "Illegal size ret in GetExtAttr\n");
Steve French790fe572007-07-07 19:25:05 +00003647 rc = -EIO;
3648 goto GetExtAttrOut;
3649 }
3650 pfinfo = (struct file_chattr_info *)
3651 (data_offset + (char *) &pSMBr->hdr.Protocol);
3652 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
Steve Frenchf654bac2005-04-28 22:41:04 -07003653 *pMask = le64_to_cpu(pfinfo->mask);
Steve French790fe572007-07-07 19:25:05 +00003654 }
3655 }
Steve Frenchf654bac2005-04-28 22:41:04 -07003656GetExtAttrOut:
Steve French790fe572007-07-07 19:25:05 +00003657 cifs_buf_release(pSMB);
3658 if (rc == -EAGAIN)
3659 goto GetExtAttrRetry;
3660 return rc;
Steve Frenchf654bac2005-04-28 22:41:04 -07003661}
3662
Steve Frenchf654bac2005-04-28 22:41:04 -07003663#endif /* CONFIG_POSIX */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664
Jeff Layton79df1ba2010-12-06 12:52:08 -05003665#ifdef CONFIG_CIFS_ACL
3666/*
3667 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3668 * all NT TRANSACTS that we init here have total parm and data under about 400
3669 * bytes (to fit in small cifs buffer size), which is the case so far, it
3670 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3671 * returned setup area) and MaxParameterCount (returned parms size) must be set
3672 * by caller
3673 */
3674static int
3675smb_init_nttransact(const __u16 sub_command, const int setup_count,
Steve French96daf2b2011-05-27 04:34:02 +00003676 const int parm_len, struct cifs_tcon *tcon,
Jeff Layton79df1ba2010-12-06 12:52:08 -05003677 void **ret_buf)
3678{
3679 int rc;
3680 __u32 temp_offset;
3681 struct smb_com_ntransact_req *pSMB;
3682
3683 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3684 (void **)&pSMB);
3685 if (rc)
3686 return rc;
3687 *ret_buf = (void *)pSMB;
3688 pSMB->Reserved = 0;
3689 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3690 pSMB->TotalDataCount = 0;
Jeff Laytonc974bef2011-10-11 06:41:32 -04003691 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Jeff Layton79df1ba2010-12-06 12:52:08 -05003692 pSMB->ParameterCount = pSMB->TotalParameterCount;
3693 pSMB->DataCount = pSMB->TotalDataCount;
3694 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3695 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3696 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3697 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3698 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3699 pSMB->SubCommand = cpu_to_le16(sub_command);
3700 return 0;
3701}
3702
3703static int
3704validate_ntransact(char *buf, char **ppparm, char **ppdata,
3705 __u32 *pparmlen, __u32 *pdatalen)
3706{
3707 char *end_of_smb;
3708 __u32 data_count, data_offset, parm_count, parm_offset;
3709 struct smb_com_ntransact_rsp *pSMBr;
Jeff Layton820a8032011-05-04 08:05:26 -04003710 u16 bcc;
Jeff Layton79df1ba2010-12-06 12:52:08 -05003711
3712 *pdatalen = 0;
3713 *pparmlen = 0;
3714
3715 if (buf == NULL)
3716 return -EINVAL;
3717
3718 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3719
Jeff Layton820a8032011-05-04 08:05:26 -04003720 bcc = get_bcc(&pSMBr->hdr);
3721 end_of_smb = 2 /* sizeof byte count */ + bcc +
Jeff Layton79df1ba2010-12-06 12:52:08 -05003722 (char *)&pSMBr->ByteCount;
3723
3724 data_offset = le32_to_cpu(pSMBr->DataOffset);
3725 data_count = le32_to_cpu(pSMBr->DataCount);
3726 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3727 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3728
3729 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3730 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3731
3732 /* should we also check that parm and data areas do not overlap? */
3733 if (*ppparm > end_of_smb) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003734 cifs_dbg(FYI, "parms start after end of smb\n");
Jeff Layton79df1ba2010-12-06 12:52:08 -05003735 return -EINVAL;
3736 } else if (parm_count + *ppparm > end_of_smb) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003737 cifs_dbg(FYI, "parm end after end of smb\n");
Jeff Layton79df1ba2010-12-06 12:52:08 -05003738 return -EINVAL;
3739 } else if (*ppdata > end_of_smb) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003740 cifs_dbg(FYI, "data starts after end of smb\n");
Jeff Layton79df1ba2010-12-06 12:52:08 -05003741 return -EINVAL;
3742 } else if (data_count + *ppdata > end_of_smb) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003743 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3744 *ppdata, data_count, (data_count + *ppdata),
3745 end_of_smb, pSMBr);
Jeff Layton79df1ba2010-12-06 12:52:08 -05003746 return -EINVAL;
Jeff Layton820a8032011-05-04 08:05:26 -04003747 } else if (parm_count + data_count > bcc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003748 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
Jeff Layton79df1ba2010-12-06 12:52:08 -05003749 return -EINVAL;
3750 }
3751 *pdatalen = data_count;
3752 *pparmlen = parm_count;
3753 return 0;
3754}
3755
Steve French0a4b92c2006-01-12 15:44:21 -08003756/* Get Security Descriptor (by handle) from remote server for a file or dir */
3757int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003758CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
Steve French630f3f0c2007-10-25 21:17:17 +00003759 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
Steve French0a4b92c2006-01-12 15:44:21 -08003760{
3761 int rc = 0;
3762 int buf_type = 0;
Steve Frenchad7a2922008-02-07 23:25:02 +00003763 QUERY_SEC_DESC_REQ *pSMB;
Steve French0a4b92c2006-01-12 15:44:21 -08003764 struct kvec iov[1];
3765
Joe Perchesf96637b2013-05-04 22:12:25 -05003766 cifs_dbg(FYI, "GetCifsACL\n");
Steve French0a4b92c2006-01-12 15:44:21 -08003767
Steve French630f3f0c2007-10-25 21:17:17 +00003768 *pbuflen = 0;
3769 *acl_inf = NULL;
3770
Steve Frenchb9c7a2b2007-10-26 23:40:20 +00003771 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
Steve French0a4b92c2006-01-12 15:44:21 -08003772 8 /* parm len */, tcon, (void **) &pSMB);
3773 if (rc)
3774 return rc;
3775
3776 pSMB->MaxParameterCount = cpu_to_le32(4);
3777 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3778 pSMB->MaxSetupCount = 0;
3779 pSMB->Fid = fid; /* file handle always le */
3780 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3781 CIFS_ACL_DACL);
3782 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003783 inc_rfc1001_len(pSMB, 11);
Steve French0a4b92c2006-01-12 15:44:21 -08003784 iov[0].iov_base = (char *)pSMB;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003785 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
Steve French0a4b92c2006-01-12 15:44:21 -08003786
Steve Frencha761ac52007-10-18 21:45:27 +00003787 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
Jeff Layton77499812011-01-11 07:24:23 -05003788 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04003789 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
Steve French0a4b92c2006-01-12 15:44:21 -08003790 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003791 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
Steve French0a4b92c2006-01-12 15:44:21 -08003792 } else { /* decode response */
Steve Frenchad7a2922008-02-07 23:25:02 +00003793 __le32 *parm;
Steve French630f3f0c2007-10-25 21:17:17 +00003794 __u32 parm_len;
3795 __u32 acl_len;
Steve French50c2f752007-07-13 00:33:32 +00003796 struct smb_com_ntransact_rsp *pSMBr;
Steve French630f3f0c2007-10-25 21:17:17 +00003797 char *pdata;
Steve French0a4b92c2006-01-12 15:44:21 -08003798
3799/* validate_nttransact */
Steve French50c2f752007-07-13 00:33:32 +00003800 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
Steve French630f3f0c2007-10-25 21:17:17 +00003801 &pdata, &parm_len, pbuflen);
Steve French790fe572007-07-07 19:25:05 +00003802 if (rc)
Steve French0a4b92c2006-01-12 15:44:21 -08003803 goto qsec_out;
3804 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3805
Joe Perchesf96637b2013-05-04 22:12:25 -05003806 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3807 pSMBr, parm, *acl_inf);
Steve French0a4b92c2006-01-12 15:44:21 -08003808
3809 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3810 rc = -EIO; /* bad smb */
Steve French630f3f0c2007-10-25 21:17:17 +00003811 *pbuflen = 0;
Steve French0a4b92c2006-01-12 15:44:21 -08003812 goto qsec_out;
3813 }
3814
3815/* BB check that data area is minimum length and as big as acl_len */
3816
Steve Frenchaf6f4612007-10-16 18:40:37 +00003817 acl_len = le32_to_cpu(*parm);
Steve French630f3f0c2007-10-25 21:17:17 +00003818 if (acl_len != *pbuflen) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003819 cifs_dbg(VFS, "acl length %d does not match %d\n",
3820 acl_len, *pbuflen);
Steve French630f3f0c2007-10-25 21:17:17 +00003821 if (*pbuflen > acl_len)
3822 *pbuflen = acl_len;
3823 }
Steve French0a4b92c2006-01-12 15:44:21 -08003824
Steve French630f3f0c2007-10-25 21:17:17 +00003825 /* check if buffer is big enough for the acl
3826 header followed by the smallest SID */
3827 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3828 (*pbuflen >= 64 * 1024)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003829 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
Steve French630f3f0c2007-10-25 21:17:17 +00003830 rc = -EINVAL;
3831 *pbuflen = 0;
3832 } else {
Silviu-Mihai Popescuf7f7c182013-03-11 18:22:32 +02003833 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
Steve French630f3f0c2007-10-25 21:17:17 +00003834 if (*acl_inf == NULL) {
3835 *pbuflen = 0;
3836 rc = -ENOMEM;
3837 }
Steve French630f3f0c2007-10-25 21:17:17 +00003838 }
Steve French0a4b92c2006-01-12 15:44:21 -08003839 }
3840qsec_out:
Steve French790fe572007-07-07 19:25:05 +00003841 if (buf_type == CIFS_SMALL_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003842 cifs_small_buf_release(iov[0].iov_base);
Steve French790fe572007-07-07 19:25:05 +00003843 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French0a4b92c2006-01-12 15:44:21 -08003844 cifs_buf_release(iov[0].iov_base);
Steve French4b8f9302006-02-26 16:41:18 +00003845/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
Steve French0a4b92c2006-01-12 15:44:21 -08003846 return rc;
3847}
Steve French97837582007-12-31 07:47:21 +00003848
3849int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003850CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003851 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
Steve French97837582007-12-31 07:47:21 +00003852{
3853 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3854 int rc = 0;
3855 int bytes_returned = 0;
3856 SET_SEC_DESC_REQ *pSMB = NULL;
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04003857 void *pSMBr;
Steve French97837582007-12-31 07:47:21 +00003858
3859setCifsAclRetry:
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04003860 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
Steve French97837582007-12-31 07:47:21 +00003861 if (rc)
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04003862 return rc;
Steve French97837582007-12-31 07:47:21 +00003863
3864 pSMB->MaxSetupCount = 0;
3865 pSMB->Reserved = 0;
3866
3867 param_count = 8;
3868 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3869 data_count = acllen;
3870 data_offset = param_offset + param_count;
3871 byte_count = 3 /* pad */ + param_count;
3872
3873 pSMB->DataCount = cpu_to_le32(data_count);
3874 pSMB->TotalDataCount = pSMB->DataCount;
3875 pSMB->MaxParameterCount = cpu_to_le32(4);
3876 pSMB->MaxDataCount = cpu_to_le32(16384);
3877 pSMB->ParameterCount = cpu_to_le32(param_count);
3878 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3879 pSMB->TotalParameterCount = pSMB->ParameterCount;
3880 pSMB->DataOffset = cpu_to_le32(data_offset);
3881 pSMB->SetupCount = 0;
3882 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3883 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3884
3885 pSMB->Fid = fid; /* file handle always le */
3886 pSMB->Reserved2 = 0;
Shirish Pargaonkara5ff3762011-10-13 10:26:03 -05003887 pSMB->AclFlags = cpu_to_le32(aclflag);
Steve French97837582007-12-31 07:47:21 +00003888
3889 if (pntsd && acllen) {
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04003890 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
3891 data_offset, pntsd, acllen);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003892 inc_rfc1001_len(pSMB, byte_count + data_count);
Steve French97837582007-12-31 07:47:21 +00003893 } else
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003894 inc_rfc1001_len(pSMB, byte_count);
Steve French97837582007-12-31 07:47:21 +00003895
3896 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3897 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3898
Joe Perchesf96637b2013-05-04 22:12:25 -05003899 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3900 bytes_returned, rc);
Steve French97837582007-12-31 07:47:21 +00003901 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003902 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
Steve French97837582007-12-31 07:47:21 +00003903 cifs_buf_release(pSMB);
3904
3905 if (rc == -EAGAIN)
3906 goto setCifsAclRetry;
3907
3908 return (rc);
3909}
3910
Jeff Layton79df1ba2010-12-06 12:52:08 -05003911#endif /* CONFIG_CIFS_ACL */
Steve French0a4b92c2006-01-12 15:44:21 -08003912
Steve French6b8edfe2005-08-23 20:26:03 -07003913/* Legacy Query Path Information call for lookup to old servers such
3914 as Win9x/WinME */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003915int
3916SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
3917 const char *search_name, FILE_ALL_INFO *data,
3918 const struct nls_table *nls_codepage, int remap)
Steve French6b8edfe2005-08-23 20:26:03 -07003919{
Steve Frenchad7a2922008-02-07 23:25:02 +00003920 QUERY_INFORMATION_REQ *pSMB;
3921 QUERY_INFORMATION_RSP *pSMBr;
Steve French6b8edfe2005-08-23 20:26:03 -07003922 int rc = 0;
3923 int bytes_returned;
3924 int name_len;
3925
Joe Perchesf96637b2013-05-04 22:12:25 -05003926 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
Steve French6b8edfe2005-08-23 20:26:03 -07003927QInfRetry:
3928 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003929 (void **) &pSMBr);
Steve French6b8edfe2005-08-23 20:26:03 -07003930 if (rc)
3931 return rc;
3932
3933 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3934 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06003935 cifsConvertToUTF16((__le16 *) pSMB->FileName,
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003936 search_name, PATH_MAX, nls_codepage,
Steve Frenchacbbb762012-01-18 22:32:33 -06003937 remap);
Steve French6b8edfe2005-08-23 20:26:03 -07003938 name_len++; /* trailing null */
3939 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00003940 } else {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003941 name_len = strnlen(search_name, PATH_MAX);
Steve French6b8edfe2005-08-23 20:26:03 -07003942 name_len++; /* trailing null */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003943 strncpy(pSMB->FileName, search_name, name_len);
Steve French6b8edfe2005-08-23 20:26:03 -07003944 }
3945 pSMB->BufferFormat = 0x04;
Steve French50c2f752007-07-13 00:33:32 +00003946 name_len++; /* account for buffer type byte */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003947 inc_rfc1001_len(pSMB, (__u16)name_len);
Steve French6b8edfe2005-08-23 20:26:03 -07003948 pSMB->ByteCount = cpu_to_le16(name_len);
3949
3950 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
Steve French50c2f752007-07-13 00:33:32 +00003951 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve French6b8edfe2005-08-23 20:26:03 -07003952 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003953 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003954 } else if (data) {
Steve French1bd5bbc2006-09-28 03:35:57 +00003955 struct timespec ts;
3956 __u32 time = le32_to_cpu(pSMBr->last_write_time);
Steve Frenchad7a2922008-02-07 23:25:02 +00003957
3958 /* decode response */
Steve French1bd5bbc2006-09-28 03:35:57 +00003959 /* BB FIXME - add time zone adjustment BB */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003960 memset(data, 0, sizeof(FILE_ALL_INFO));
Steve French1bd5bbc2006-09-28 03:35:57 +00003961 ts.tv_nsec = 0;
3962 ts.tv_sec = time;
3963 /* decode time fields */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003964 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3965 data->LastWriteTime = data->ChangeTime;
3966 data->LastAccessTime = 0;
3967 data->AllocationSize =
Steve French70ca7342005-09-22 16:32:06 -07003968 cpu_to_le64(le32_to_cpu(pSMBr->size));
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003969 data->EndOfFile = data->AllocationSize;
3970 data->Attributes =
Steve French70ca7342005-09-22 16:32:06 -07003971 cpu_to_le32(le16_to_cpu(pSMBr->attr));
Steve French6b8edfe2005-08-23 20:26:03 -07003972 } else
3973 rc = -EIO; /* bad buffer passed in */
3974
3975 cifs_buf_release(pSMB);
3976
3977 if (rc == -EAGAIN)
3978 goto QInfRetry;
3979
3980 return rc;
3981}
3982
Jeff Laytonbcd53572010-02-12 07:44:16 -05003983int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003984CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Laytonbcd53572010-02-12 07:44:16 -05003985 u16 netfid, FILE_ALL_INFO *pFindData)
3986{
3987 struct smb_t2_qfi_req *pSMB = NULL;
3988 struct smb_t2_qfi_rsp *pSMBr = NULL;
3989 int rc = 0;
3990 int bytes_returned;
3991 __u16 params, byte_count;
Steve French6b8edfe2005-08-23 20:26:03 -07003992
Jeff Laytonbcd53572010-02-12 07:44:16 -05003993QFileInfoRetry:
3994 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3995 (void **) &pSMBr);
3996 if (rc)
3997 return rc;
Steve French6b8edfe2005-08-23 20:26:03 -07003998
Jeff Laytonbcd53572010-02-12 07:44:16 -05003999 params = 2 /* level */ + 2 /* fid */;
4000 pSMB->t2.TotalDataCount = 0;
4001 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4002 /* BB find exact max data count below from sess structure BB */
4003 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4004 pSMB->t2.MaxSetupCount = 0;
4005 pSMB->t2.Reserved = 0;
4006 pSMB->t2.Flags = 0;
4007 pSMB->t2.Timeout = 0;
4008 pSMB->t2.Reserved2 = 0;
4009 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4010 Fid) - 4);
4011 pSMB->t2.DataCount = 0;
4012 pSMB->t2.DataOffset = 0;
4013 pSMB->t2.SetupCount = 1;
4014 pSMB->t2.Reserved3 = 0;
4015 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4016 byte_count = params + 1 /* pad */ ;
4017 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4018 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4019 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4020 pSMB->Pad = 0;
4021 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004022 inc_rfc1001_len(pSMB, byte_count);
David Disseldorp7ac0feb2013-06-28 11:47:33 +02004023 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
Jeff Laytonbcd53572010-02-12 07:44:16 -05004024
4025 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4026 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4027 if (rc) {
Steve Frenchebcc9432013-12-09 09:18:09 -06004028 cifs_dbg(FYI, "Send error in QFileInfo = %d", rc);
Jeff Laytonbcd53572010-02-12 07:44:16 -05004029 } else { /* decode response */
4030 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4031
4032 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4033 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004034 else if (get_bcc(&pSMBr->hdr) < 40)
Jeff Laytonbcd53572010-02-12 07:44:16 -05004035 rc = -EIO; /* bad smb */
4036 else if (pFindData) {
4037 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4038 memcpy((char *) pFindData,
4039 (char *) &pSMBr->hdr.Protocol +
4040 data_offset, sizeof(FILE_ALL_INFO));
4041 } else
4042 rc = -ENOMEM;
4043 }
4044 cifs_buf_release(pSMB);
4045 if (rc == -EAGAIN)
4046 goto QFileInfoRetry;
4047
4048 return rc;
4049}
Steve French6b8edfe2005-08-23 20:26:03 -07004050
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004052CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004053 const char *search_name, FILE_ALL_INFO *data,
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004054 int legacy /* old style infolevel */,
Steve French737b7582005-04-28 22:41:06 -07004055 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004056{
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004057 /* level 263 SMB_QUERY_FILE_ALL_INFO */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004058 TRANSACTION2_QPI_REQ *pSMB = NULL;
4059 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4060 int rc = 0;
4061 int bytes_returned;
4062 int name_len;
4063 __u16 params, byte_count;
4064
Joe Perchesf96637b2013-05-04 22:12:25 -05004065 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004066QPathInfoRetry:
4067 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4068 (void **) &pSMBr);
4069 if (rc)
4070 return rc;
4071
4072 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4073 name_len =
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004074 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
Steve Frenchacbbb762012-01-18 22:32:33 -06004075 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004076 name_len++; /* trailing null */
4077 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004078 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004079 name_len = strnlen(search_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004080 name_len++; /* trailing null */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004081 strncpy(pSMB->FileName, search_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004082 }
4083
Steve French50c2f752007-07-13 00:33:32 +00004084 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085 pSMB->TotalDataCount = 0;
4086 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00004087 /* BB find exact max SMB PDU from sess structure BB */
4088 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089 pSMB->MaxSetupCount = 0;
4090 pSMB->Reserved = 0;
4091 pSMB->Flags = 0;
4092 pSMB->Timeout = 0;
4093 pSMB->Reserved2 = 0;
4094 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004095 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004096 pSMB->DataCount = 0;
4097 pSMB->DataOffset = 0;
4098 pSMB->SetupCount = 1;
4099 pSMB->Reserved3 = 0;
4100 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4101 byte_count = params + 1 /* pad */ ;
4102 pSMB->TotalParameterCount = cpu_to_le16(params);
4103 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve French790fe572007-07-07 19:25:05 +00004104 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004105 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4106 else
4107 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004108 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004109 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004110 pSMB->ByteCount = cpu_to_le16(byte_count);
4111
4112 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4113 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4114 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004115 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004116 } else { /* decode response */
4117 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4118
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004119 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4120 rc = -EIO;
Jeff Layton820a8032011-05-04 08:05:26 -04004121 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004122 rc = -EIO; /* bad smb */
Jeff Layton820a8032011-05-04 08:05:26 -04004123 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
Steve French50c2f752007-07-13 00:33:32 +00004124 rc = -EIO; /* 24 or 26 expected but we do not read
4125 last field */
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004126 else if (data) {
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004127 int size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004128 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Steve Frenchad7a2922008-02-07 23:25:02 +00004129
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004130 /*
4131 * On legacy responses we do not read the last field,
4132 * EAsize, fortunately since it varies by subdialect and
4133 * also note it differs on Set vs Get, ie two bytes or 4
4134 * bytes depending but we don't care here.
4135 */
Steve Frenchad7a2922008-02-07 23:25:02 +00004136 if (legacy)
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004137 size = sizeof(FILE_INFO_STANDARD);
4138 else
4139 size = sizeof(FILE_ALL_INFO);
Pavel Shilovsky68889f22012-05-25 14:40:22 +04004140 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
Steve Frenchacf1a1b2006-10-12 03:28:28 +00004141 data_offset, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004142 } else
4143 rc = -ENOMEM;
4144 }
4145 cifs_buf_release(pSMB);
4146 if (rc == -EAGAIN)
4147 goto QPathInfoRetry;
4148
4149 return rc;
4150}
4151
4152int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004153CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004154 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4155{
4156 struct smb_t2_qfi_req *pSMB = NULL;
4157 struct smb_t2_qfi_rsp *pSMBr = NULL;
4158 int rc = 0;
4159 int bytes_returned;
4160 __u16 params, byte_count;
4161
4162UnixQFileInfoRetry:
4163 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4164 (void **) &pSMBr);
4165 if (rc)
4166 return rc;
4167
4168 params = 2 /* level */ + 2 /* fid */;
4169 pSMB->t2.TotalDataCount = 0;
4170 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4171 /* BB find exact max data count below from sess structure BB */
4172 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4173 pSMB->t2.MaxSetupCount = 0;
4174 pSMB->t2.Reserved = 0;
4175 pSMB->t2.Flags = 0;
4176 pSMB->t2.Timeout = 0;
4177 pSMB->t2.Reserved2 = 0;
4178 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4179 Fid) - 4);
4180 pSMB->t2.DataCount = 0;
4181 pSMB->t2.DataOffset = 0;
4182 pSMB->t2.SetupCount = 1;
4183 pSMB->t2.Reserved3 = 0;
4184 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4185 byte_count = params + 1 /* pad */ ;
4186 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4187 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4188 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4189 pSMB->Pad = 0;
4190 pSMB->Fid = netfid;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004191 inc_rfc1001_len(pSMB, byte_count);
David Disseldorp7ac0feb2013-06-28 11:47:33 +02004192 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004193
4194 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4195 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4196 if (rc) {
Steve Frenchebcc9432013-12-09 09:18:09 -06004197 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d", rc);
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004198 } else { /* decode response */
4199 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4200
Jeff Layton820a8032011-05-04 08:05:26 -04004201 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004202 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
Jeff Laytonc8634fd2010-02-12 07:44:17 -05004203 rc = -EIO; /* bad smb */
4204 } else {
4205 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4206 memcpy((char *) pFindData,
4207 (char *) &pSMBr->hdr.Protocol +
4208 data_offset,
4209 sizeof(FILE_UNIX_BASIC_INFO));
4210 }
4211 }
4212
4213 cifs_buf_release(pSMB);
4214 if (rc == -EAGAIN)
4215 goto UnixQFileInfoRetry;
4216
4217 return rc;
4218}
4219
4220int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004221CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004222 const unsigned char *searchName,
Steve French582d21e2008-05-13 04:54:12 +00004223 FILE_UNIX_BASIC_INFO *pFindData,
Steve French737b7582005-04-28 22:41:06 -07004224 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225{
4226/* SMB_QUERY_FILE_UNIX_BASIC */
4227 TRANSACTION2_QPI_REQ *pSMB = NULL;
4228 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4229 int rc = 0;
4230 int bytes_returned = 0;
4231 int name_len;
4232 __u16 params, byte_count;
4233
Joe Perchesf96637b2013-05-04 22:12:25 -05004234 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004235UnixQPathInfoRetry:
4236 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4237 (void **) &pSMBr);
4238 if (rc)
4239 return rc;
4240
4241 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4242 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004243 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4244 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004245 name_len++; /* trailing null */
4246 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004247 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004248 name_len = strnlen(searchName, PATH_MAX);
4249 name_len++; /* trailing null */
4250 strncpy(pSMB->FileName, searchName, name_len);
4251 }
4252
Steve French50c2f752007-07-13 00:33:32 +00004253 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004254 pSMB->TotalDataCount = 0;
4255 pSMB->MaxParameterCount = cpu_to_le16(2);
4256 /* BB find exact max SMB PDU from sess structure BB */
Steve French50c2f752007-07-13 00:33:32 +00004257 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004258 pSMB->MaxSetupCount = 0;
4259 pSMB->Reserved = 0;
4260 pSMB->Flags = 0;
4261 pSMB->Timeout = 0;
4262 pSMB->Reserved2 = 0;
4263 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004264 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004265 pSMB->DataCount = 0;
4266 pSMB->DataOffset = 0;
4267 pSMB->SetupCount = 1;
4268 pSMB->Reserved3 = 0;
4269 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4270 byte_count = params + 1 /* pad */ ;
4271 pSMB->TotalParameterCount = cpu_to_le16(params);
4272 pSMB->ParameterCount = pSMB->TotalParameterCount;
4273 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4274 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004275 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276 pSMB->ByteCount = cpu_to_le16(byte_count);
4277
4278 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4279 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4280 if (rc) {
Steve Frenchebcc9432013-12-09 09:18:09 -06004281 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004282 } else { /* decode response */
4283 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4284
Jeff Layton820a8032011-05-04 08:05:26 -04004285 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004286 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004287 rc = -EIO; /* bad smb */
4288 } else {
4289 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4290 memcpy((char *) pFindData,
4291 (char *) &pSMBr->hdr.Protocol +
4292 data_offset,
Steve French630f3f0c2007-10-25 21:17:17 +00004293 sizeof(FILE_UNIX_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004294 }
4295 }
4296 cifs_buf_release(pSMB);
4297 if (rc == -EAGAIN)
4298 goto UnixQPathInfoRetry;
4299
4300 return rc;
4301}
4302
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303/* xid, tcon, searchName and codepage are input parms, rest are returned */
4304int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004305CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004306 const char *searchName, struct cifs_sb_info *cifs_sb,
Shirish Pargaonkar2608bee2012-05-15 10:19:16 -05004307 __u16 *pnetfid, __u16 search_flags,
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004308 struct cifs_search_info *psrch_inf, bool msearch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309{
4310/* level 257 SMB_ */
4311 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4312 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004313 T2_FFIRST_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004314 int rc = 0;
4315 int bytes_returned = 0;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004316 int name_len, remap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317 __u16 params, byte_count;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004318 struct nls_table *nls_codepage;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004319
Joe Perchesf96637b2013-05-04 22:12:25 -05004320 cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321
4322findFirstRetry:
4323 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4324 (void **) &pSMBr);
4325 if (rc)
4326 return rc;
4327
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004328 nls_codepage = cifs_sb->local_nls;
4329 remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
4330
Linus Torvalds1da177e2005-04-16 15:20:36 -07004331 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4332 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004333 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4334 PATH_MAX, nls_codepage, remap);
Steve French737b7582005-04-28 22:41:06 -07004335 /* We can not add the asterik earlier in case
4336 it got remapped to 0xF03A as if it were part of the
4337 directory name instead of a wildcard */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004338 name_len *= 2;
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004339 if (msearch) {
4340 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4341 pSMB->FileName[name_len+1] = 0;
4342 pSMB->FileName[name_len+2] = '*';
4343 pSMB->FileName[name_len+3] = 0;
4344 name_len += 4; /* now the trailing null */
4345 /* null terminate just in case */
4346 pSMB->FileName[name_len] = 0;
4347 pSMB->FileName[name_len+1] = 0;
4348 name_len += 2;
4349 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350 } else { /* BB add check for overrun of SMB buf BB */
4351 name_len = strnlen(searchName, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004352/* BB fix here and in unicode clause above ie
Steve French790fe572007-07-07 19:25:05 +00004353 if (name_len > buffersize-header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004354 free buffer exit; BB */
4355 strncpy(pSMB->FileName, searchName, name_len);
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004356 if (msearch) {
4357 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4358 pSMB->FileName[name_len+1] = '*';
4359 pSMB->FileName[name_len+2] = 0;
4360 name_len += 3;
4361 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004362 }
4363
4364 params = 12 + name_len /* includes null */ ;
4365 pSMB->TotalDataCount = 0; /* no EAs */
4366 pSMB->MaxParameterCount = cpu_to_le16(10);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004367 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004368 pSMB->MaxSetupCount = 0;
4369 pSMB->Reserved = 0;
4370 pSMB->Flags = 0;
4371 pSMB->Timeout = 0;
4372 pSMB->Reserved2 = 0;
4373 byte_count = params + 1 /* pad */ ;
4374 pSMB->TotalParameterCount = cpu_to_le16(params);
4375 pSMB->ParameterCount = pSMB->TotalParameterCount;
4376 pSMB->ParameterOffset = cpu_to_le16(
Steve French88274812006-03-09 22:21:45 +00004377 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4378 - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004379 pSMB->DataCount = 0;
4380 pSMB->DataOffset = 0;
4381 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4382 pSMB->Reserved3 = 0;
4383 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4384 pSMB->SearchAttributes =
4385 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4386 ATTR_DIRECTORY);
Steve French50c2f752007-07-13 00:33:32 +00004387 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
Shirish Pargaonkar2608bee2012-05-15 10:19:16 -05004388 pSMB->SearchFlags = cpu_to_le16(search_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004389 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4390
4391 /* BB what should we set StorageType to? Does it matter? BB */
4392 pSMB->SearchStorageType = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004393 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004394 pSMB->ByteCount = cpu_to_le16(byte_count);
4395
4396 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4397 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04004398 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004399
Steve French88274812006-03-09 22:21:45 +00004400 if (rc) {/* BB add logic to retry regular search if Unix search
4401 rejected unexpectedly by server */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402 /* BB Add code to handle unsupported level rc */
Joe Perchesf96637b2013-05-04 22:12:25 -05004403 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
Steve French1982c342005-08-17 12:38:22 -07004404
Steve French88274812006-03-09 22:21:45 +00004405 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004406
4407 /* BB eventually could optimize out free and realloc of buf */
4408 /* for this case */
4409 if (rc == -EAGAIN)
4410 goto findFirstRetry;
4411 } else { /* decode response */
4412 /* BB remember to free buffer if error BB */
4413 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French790fe572007-07-07 19:25:05 +00004414 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004415 unsigned int lnoff;
4416
Linus Torvalds1da177e2005-04-16 15:20:36 -07004417 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004418 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419 else
Steve French4b18f2a2008-04-29 00:06:05 +00004420 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004421
4422 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004423 psrch_inf->smallBuf = 0;
Steve French50c2f752007-07-13 00:33:32 +00004424 psrch_inf->srch_entries_start =
4425 (char *) &pSMBr->hdr.Protocol +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004426 le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004427 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4428 le16_to_cpu(pSMBr->t2.ParameterOffset));
4429
Steve French790fe572007-07-07 19:25:05 +00004430 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004431 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004432 else
Steve French4b18f2a2008-04-29 00:06:05 +00004433 psrch_inf->endOfSearch = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434
Steve French50c2f752007-07-13 00:33:32 +00004435 psrch_inf->entries_in_buffer =
4436 le16_to_cpu(parms->SearchCount);
Steve French60808232006-04-22 15:53:05 +00004437 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
Linus Torvalds1da177e2005-04-16 15:20:36 -07004438 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004439 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004440 if (CIFSMaxBufSize < lnoff) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004441 cifs_dbg(VFS, "ignoring corrupt resume name\n");
Steve Frenchb77d7532008-10-08 19:13:46 +00004442 psrch_inf->last_entry = NULL;
4443 return rc;
4444 }
4445
Steve French0752f152008-10-07 20:03:33 +00004446 psrch_inf->last_entry = psrch_inf->srch_entries_start +
Steve Frenchb77d7532008-10-08 19:13:46 +00004447 lnoff;
4448
Shirish Pargaonkarc052e2b2012-09-28 12:21:14 -05004449 if (pnetfid)
4450 *pnetfid = parms->SearchHandle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004451 } else {
4452 cifs_buf_release(pSMB);
4453 }
4454 }
4455
4456 return rc;
4457}
4458
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004459int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4460 __u16 searchHandle, __u16 search_flags,
4461 struct cifs_search_info *psrch_inf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004462{
4463 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4464 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
Steve Frenchad7a2922008-02-07 23:25:02 +00004465 T2_FNEXT_RSP_PARMS *parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004466 char *response_data;
4467 int rc = 0;
Jeff Layton9438fab2011-08-23 07:21:28 -04004468 int bytes_returned;
4469 unsigned int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004470 __u16 params, byte_count;
4471
Joe Perchesf96637b2013-05-04 22:12:25 -05004472 cifs_dbg(FYI, "In FindNext\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004473
Steve French4b18f2a2008-04-29 00:06:05 +00004474 if (psrch_inf->endOfSearch)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004475 return -ENOENT;
4476
4477 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4478 (void **) &pSMBr);
4479 if (rc)
4480 return rc;
4481
Steve French50c2f752007-07-13 00:33:32 +00004482 params = 14; /* includes 2 bytes of null string, converted to LE below*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004483 byte_count = 0;
4484 pSMB->TotalDataCount = 0; /* no EAs */
4485 pSMB->MaxParameterCount = cpu_to_le16(8);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004486 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004487 pSMB->MaxSetupCount = 0;
4488 pSMB->Reserved = 0;
4489 pSMB->Flags = 0;
4490 pSMB->Timeout = 0;
4491 pSMB->Reserved2 = 0;
4492 pSMB->ParameterOffset = cpu_to_le16(
4493 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4494 pSMB->DataCount = 0;
4495 pSMB->DataOffset = 0;
4496 pSMB->SetupCount = 1;
4497 pSMB->Reserved3 = 0;
4498 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4499 pSMB->SearchHandle = searchHandle; /* always kept as le */
4500 pSMB->SearchCount =
Steve French630f3f0c2007-10-25 21:17:17 +00004501 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004502 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4503 pSMB->ResumeKey = psrch_inf->resume_key;
Shirish Pargaonkar2608bee2012-05-15 10:19:16 -05004504 pSMB->SearchFlags = cpu_to_le16(search_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004505
4506 name_len = psrch_inf->resume_name_len;
4507 params += name_len;
Steve French790fe572007-07-07 19:25:05 +00004508 if (name_len < PATH_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004509 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4510 byte_count += name_len;
Steve Frenchef6724e2005-08-02 21:31:05 -07004511 /* 14 byte parm len above enough for 2 byte null terminator */
4512 pSMB->ResumeFileName[name_len] = 0;
4513 pSMB->ResumeFileName[name_len+1] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004514 } else {
4515 rc = -EINVAL;
4516 goto FNext2_err_exit;
4517 }
4518 byte_count = params + 1 /* pad */ ;
4519 pSMB->TotalParameterCount = cpu_to_le16(params);
4520 pSMB->ParameterCount = pSMB->TotalParameterCount;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004521 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004522 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00004523
Linus Torvalds1da177e2005-04-16 15:20:36 -07004524 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4525 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Pavel Shilovsky44c58182012-05-28 14:16:31 +04004526 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004527 if (rc) {
4528 if (rc == -EBADF) {
Steve French4b18f2a2008-04-29 00:06:05 +00004529 psrch_inf->endOfSearch = true;
Jeff Layton63534502008-05-12 19:56:05 -07004530 cifs_buf_release(pSMB);
Steve French50c2f752007-07-13 00:33:32 +00004531 rc = 0; /* search probably was closed at end of search*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07004532 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05004533 cifs_dbg(FYI, "FindNext returned = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004534 } else { /* decode response */
4535 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve French50c2f752007-07-13 00:33:32 +00004536
Steve French790fe572007-07-07 19:25:05 +00004537 if (rc == 0) {
Steve Frenchb77d7532008-10-08 19:13:46 +00004538 unsigned int lnoff;
4539
Linus Torvalds1da177e2005-04-16 15:20:36 -07004540 /* BB fixme add lock for file (srch_info) struct here */
4541 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
Steve French4b18f2a2008-04-29 00:06:05 +00004542 psrch_inf->unicode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004543 else
Steve French4b18f2a2008-04-29 00:06:05 +00004544 psrch_inf->unicode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004545 response_data = (char *) &pSMBr->hdr.Protocol +
4546 le16_to_cpu(pSMBr->t2.ParameterOffset);
4547 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4548 response_data = (char *)&pSMBr->hdr.Protocol +
4549 le16_to_cpu(pSMBr->t2.DataOffset);
Steve French790fe572007-07-07 19:25:05 +00004550 if (psrch_inf->smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +00004551 cifs_small_buf_release(
4552 psrch_inf->ntwrk_buf_start);
4553 else
4554 cifs_buf_release(psrch_inf->ntwrk_buf_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004555 psrch_inf->srch_entries_start = response_data;
4556 psrch_inf->ntwrk_buf_start = (char *)pSMB;
Steve Frenchd47d7c12006-02-28 03:45:48 +00004557 psrch_inf->smallBuf = 0;
Steve French790fe572007-07-07 19:25:05 +00004558 if (parms->EndofSearch)
Steve French4b18f2a2008-04-29 00:06:05 +00004559 psrch_inf->endOfSearch = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004560 else
Steve French4b18f2a2008-04-29 00:06:05 +00004561 psrch_inf->endOfSearch = false;
Steve French50c2f752007-07-13 00:33:32 +00004562 psrch_inf->entries_in_buffer =
4563 le16_to_cpu(parms->SearchCount);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004564 psrch_inf->index_of_last_entry +=
4565 psrch_inf->entries_in_buffer;
Steve Frenchb77d7532008-10-08 19:13:46 +00004566 lnoff = le16_to_cpu(parms->LastNameOffset);
Jeff Laytonc974bef2011-10-11 06:41:32 -04004567 if (CIFSMaxBufSize < lnoff) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004568 cifs_dbg(VFS, "ignoring corrupt resume name\n");
Steve Frenchb77d7532008-10-08 19:13:46 +00004569 psrch_inf->last_entry = NULL;
4570 return rc;
4571 } else
4572 psrch_inf->last_entry =
4573 psrch_inf->srch_entries_start + lnoff;
4574
Joe Perchesf96637b2013-05-04 22:12:25 -05004575/* cifs_dbg(FYI, "fnxt2 entries in buf %d index_of_last %d\n",
4576 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577
4578 /* BB fixme add unlock here */
4579 }
4580
4581 }
4582
4583 /* BB On error, should we leave previous search buf (and count and
4584 last entry fields) intact or free the previous one? */
4585
4586 /* Note: On -EAGAIN error only caller can retry on handle based calls
4587 since file handle passed in no longer valid */
4588FNext2_err_exit:
4589 if (rc != 0)
4590 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004591 return rc;
4592}
4593
4594int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004595CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
Steve French50c2f752007-07-13 00:33:32 +00004596 const __u16 searchHandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004597{
4598 int rc = 0;
4599 FINDCLOSE_REQ *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600
Joe Perchesf96637b2013-05-04 22:12:25 -05004601 cifs_dbg(FYI, "In CIFSSMBFindClose\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004602 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4603
4604 /* no sense returning error if session restarted
4605 as file handle has been closed */
Steve French790fe572007-07-07 19:25:05 +00004606 if (rc == -EAGAIN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004607 return 0;
4608 if (rc)
4609 return rc;
4610
Linus Torvalds1da177e2005-04-16 15:20:36 -07004611 pSMB->FileID = searchHandle;
4612 pSMB->ByteCount = 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04004613 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00004614 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05004615 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
Steve Frenchad7a2922008-02-07 23:25:02 +00004616
Pavel Shilovsky44c58182012-05-28 14:16:31 +04004617 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004618
4619 /* Since session is dead, search handle closed on server already */
4620 if (rc == -EAGAIN)
4621 rc = 0;
4622
4623 return rc;
4624}
4625
Linus Torvalds1da177e2005-04-16 15:20:36 -07004626int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004627CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04004628 const char *search_name, __u64 *inode_number,
Steve French50c2f752007-07-13 00:33:32 +00004629 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004630{
4631 int rc = 0;
4632 TRANSACTION2_QPI_REQ *pSMB = NULL;
4633 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4634 int name_len, bytes_returned;
4635 __u16 params, byte_count;
4636
Joe Perchesf96637b2013-05-04 22:12:25 -05004637 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
Steve French790fe572007-07-07 19:25:05 +00004638 if (tcon == NULL)
Steve French50c2f752007-07-13 00:33:32 +00004639 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004640
4641GetInodeNumberRetry:
4642 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
Steve French50c2f752007-07-13 00:33:32 +00004643 (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004644 if (rc)
4645 return rc;
4646
Linus Torvalds1da177e2005-04-16 15:20:36 -07004647 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4648 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004649 cifsConvertToUTF16((__le16 *) pSMB->FileName,
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04004650 search_name, PATH_MAX, nls_codepage,
Steve Frenchacbbb762012-01-18 22:32:33 -06004651 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004652 name_len++; /* trailing null */
4653 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004654 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04004655 name_len = strnlen(search_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004656 name_len++; /* trailing null */
Pavel Shilovsky1208ef12012-05-27 17:34:43 +04004657 strncpy(pSMB->FileName, search_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004658 }
4659
4660 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4661 pSMB->TotalDataCount = 0;
4662 pSMB->MaxParameterCount = cpu_to_le16(2);
4663 /* BB find exact max data count below from sess structure BB */
4664 pSMB->MaxDataCount = cpu_to_le16(4000);
4665 pSMB->MaxSetupCount = 0;
4666 pSMB->Reserved = 0;
4667 pSMB->Flags = 0;
4668 pSMB->Timeout = 0;
4669 pSMB->Reserved2 = 0;
4670 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004671 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004672 pSMB->DataCount = 0;
4673 pSMB->DataOffset = 0;
4674 pSMB->SetupCount = 1;
4675 pSMB->Reserved3 = 0;
4676 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4677 byte_count = params + 1 /* pad */ ;
4678 pSMB->TotalParameterCount = cpu_to_le16(params);
4679 pSMB->ParameterCount = pSMB->TotalParameterCount;
4680 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4681 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004682 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004683 pSMB->ByteCount = cpu_to_le16(byte_count);
4684
4685 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4686 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4687 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004688 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004689 } else {
4690 /* decode response */
4691 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004692 /* BB also check enough total bytes returned */
Jeff Layton820a8032011-05-04 08:05:26 -04004693 if (rc || get_bcc(&pSMBr->hdr) < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004694 /* If rc should we check for EOPNOSUPP and
4695 disable the srvino flag? or in caller? */
4696 rc = -EIO; /* bad smb */
Steve French50c2f752007-07-13 00:33:32 +00004697 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004698 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4699 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
Steve French50c2f752007-07-13 00:33:32 +00004700 struct file_internal_info *pfinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004701 /* BB Do we need a cast or hash here ? */
Steve French790fe572007-07-07 19:25:05 +00004702 if (count < 8) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004703 cifs_dbg(FYI, "Illegal size ret in QryIntrnlInf\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004704 rc = -EIO;
4705 goto GetInodeNumOut;
4706 }
4707 pfinfo = (struct file_internal_info *)
4708 (data_offset + (char *) &pSMBr->hdr.Protocol);
Steve French85a6dac2009-04-01 05:22:00 +00004709 *inode_number = le64_to_cpu(pfinfo->UniqueId);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004710 }
4711 }
4712GetInodeNumOut:
4713 cifs_buf_release(pSMB);
4714 if (rc == -EAGAIN)
4715 goto GetInodeNumberRetry;
4716 return rc;
4717}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004718
Igor Mammedovfec45852008-05-16 13:06:30 +04004719/* parses DFS refferal V3 structure
4720 * caller is responsible for freeing target_nodes
4721 * returns:
4722 * on success - 0
4723 * on failure - errno
4724 */
4725static int
Steve Frencha1fe78f2008-05-16 18:48:38 +00004726parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
Igor Mammedovfec45852008-05-16 13:06:30 +04004727 unsigned int *num_of_nodes,
4728 struct dfs_info3_param **target_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004729 const struct nls_table *nls_codepage, int remap,
4730 const char *searchName)
Igor Mammedovfec45852008-05-16 13:06:30 +04004731{
4732 int i, rc = 0;
4733 char *data_end;
4734 bool is_unicode;
4735 struct dfs_referral_level_3 *ref;
4736
Harvey Harrison5ca33c62008-07-23 17:45:58 -07004737 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4738 is_unicode = true;
4739 else
4740 is_unicode = false;
Igor Mammedovfec45852008-05-16 13:06:30 +04004741 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4742
4743 if (*num_of_nodes < 1) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004744 cifs_dbg(VFS, "num_referrals: must be at least > 0, but we get num_referrals = %d\n",
4745 *num_of_nodes);
Igor Mammedovfec45852008-05-16 13:06:30 +04004746 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004747 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004748 }
4749
4750 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
Al Viro1d92cfd2008-06-02 10:59:02 +01004751 if (ref->VersionNumber != cpu_to_le16(3)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004752 cifs_dbg(VFS, "Referrals of V%d version are not supported, should be V3\n",
4753 le16_to_cpu(ref->VersionNumber));
Igor Mammedovfec45852008-05-16 13:06:30 +04004754 rc = -EINVAL;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004755 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004756 }
4757
4758 /* get the upper boundary of the resp buffer */
4759 data_end = (char *)(&(pSMBr->PathConsumed)) +
4760 le16_to_cpu(pSMBr->t2.DataCount);
4761
Joe Perchesf96637b2013-05-04 22:12:25 -05004762 cifs_dbg(FYI, "num_referrals: %d dfs flags: 0x%x ...\n",
4763 *num_of_nodes, le32_to_cpu(pSMBr->DFSFlags));
Igor Mammedovfec45852008-05-16 13:06:30 +04004764
Joe Perchesf96637b2013-05-04 22:12:25 -05004765 *target_nodes = kcalloc(*num_of_nodes, sizeof(struct dfs_info3_param),
4766 GFP_KERNEL);
Igor Mammedovfec45852008-05-16 13:06:30 +04004767 if (*target_nodes == NULL) {
Igor Mammedovfec45852008-05-16 13:06:30 +04004768 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004769 goto parse_DFS_referrals_exit;
Igor Mammedovfec45852008-05-16 13:06:30 +04004770 }
4771
Daniel Mack3ad2f3f2010-02-03 08:01:28 +08004772 /* collect necessary data from referrals */
Igor Mammedovfec45852008-05-16 13:06:30 +04004773 for (i = 0; i < *num_of_nodes; i++) {
4774 char *temp;
4775 int max_len;
4776 struct dfs_info3_param *node = (*target_nodes)+i;
4777
Steve French0e0d2cf2009-05-01 05:27:32 +00004778 node->flags = le32_to_cpu(pSMBr->DFSFlags);
Igor Mammedov2c556082008-10-23 13:58:42 +04004779 if (is_unicode) {
Jeff Layton331c3132008-12-17 06:31:53 -05004780 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4781 GFP_KERNEL);
Steve French2920ee22009-08-31 15:27:26 +00004782 if (tmp == NULL) {
4783 rc = -ENOMEM;
4784 goto parse_DFS_referrals_exit;
4785 }
Steve Frenchacbbb762012-01-18 22:32:33 -06004786 cifsConvertToUTF16((__le16 *) tmp, searchName,
4787 PATH_MAX, nls_codepage, remap);
4788 node->path_consumed = cifs_utf16_bytes(tmp,
Jeff Layton69f801f2009-04-30 06:46:32 -04004789 le16_to_cpu(pSMBr->PathConsumed),
Igor Mammedov2c556082008-10-23 13:58:42 +04004790 nls_codepage);
4791 kfree(tmp);
4792 } else
4793 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4794
Igor Mammedovfec45852008-05-16 13:06:30 +04004795 node->server_type = le16_to_cpu(ref->ServerType);
4796 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4797
4798 /* copy DfsPath */
4799 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4800 max_len = data_end - temp;
Steve Frenchacbbb762012-01-18 22:32:33 -06004801 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4802 is_unicode, nls_codepage);
Jeff Laytond8e2f532009-05-14 07:46:59 -04004803 if (!node->path_name) {
4804 rc = -ENOMEM;
Steve Frencha1fe78f2008-05-16 18:48:38 +00004805 goto parse_DFS_referrals_exit;
Jeff Layton066ce682009-04-30 07:16:14 -04004806 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004807
4808 /* copy link target UNC */
4809 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4810 max_len = data_end - temp;
Steve Frenchacbbb762012-01-18 22:32:33 -06004811 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4812 is_unicode, nls_codepage);
Stefan Metzmacherd8f27992012-05-04 00:19:28 +02004813 if (!node->node_name) {
Jeff Laytond8e2f532009-05-14 07:46:59 -04004814 rc = -ENOMEM;
Stefan Metzmacherd8f27992012-05-04 00:19:28 +02004815 goto parse_DFS_referrals_exit;
4816 }
4817
4818 ref++;
Igor Mammedovfec45852008-05-16 13:06:30 +04004819 }
4820
Steve Frencha1fe78f2008-05-16 18:48:38 +00004821parse_DFS_referrals_exit:
Igor Mammedovfec45852008-05-16 13:06:30 +04004822 if (rc) {
4823 free_dfs_info_array(*target_nodes, *num_of_nodes);
4824 *target_nodes = NULL;
4825 *num_of_nodes = 0;
4826 }
4827 return rc;
4828}
4829
Linus Torvalds1da177e2005-04-16 15:20:36 -07004830int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004831CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
Pavel Shilovskyb669f332012-05-27 20:21:53 +04004832 const char *search_name, struct dfs_info3_param **target_nodes,
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004833 unsigned int *num_of_nodes,
Steve French737b7582005-04-28 22:41:06 -07004834 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004835{
4836/* TRANS2_GET_DFS_REFERRAL */
4837 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4838 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004839 int rc = 0;
4840 int bytes_returned;
4841 int name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004842 __u16 params, byte_count;
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004843 *num_of_nodes = 0;
4844 *target_nodes = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004845
Joe Perchesf96637b2013-05-04 22:12:25 -05004846 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004847 if (ses == NULL)
4848 return -ENODEV;
4849getDFSRetry:
4850 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4851 (void **) &pSMBr);
4852 if (rc)
4853 return rc;
Steve French50c2f752007-07-13 00:33:32 +00004854
4855 /* server pointer checked in called function,
Steve French1982c342005-08-17 12:38:22 -07004856 but should never be null here anyway */
Pavel Shilovsky88257362012-05-23 14:01:59 +04004857 pSMB->hdr.Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004858 pSMB->hdr.Tid = ses->ipc_tid;
4859 pSMB->hdr.Uid = ses->Suid;
Steve French26f57362007-08-30 22:09:15 +00004860 if (ses->capabilities & CAP_STATUS32)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004861 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
Steve French26f57362007-08-30 22:09:15 +00004862 if (ses->capabilities & CAP_DFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004863 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004864
4865 if (ses->capabilities & CAP_UNICODE) {
4866 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4867 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06004868 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
Pavel Shilovskyb669f332012-05-27 20:21:53 +04004869 search_name, PATH_MAX, nls_codepage,
Steve Frenchacbbb762012-01-18 22:32:33 -06004870 remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004871 name_len++; /* trailing null */
4872 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00004873 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovskyb669f332012-05-27 20:21:53 +04004874 name_len = strnlen(search_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004875 name_len++; /* trailing null */
Pavel Shilovskyb669f332012-05-27 20:21:53 +04004876 strncpy(pSMB->RequestFileName, search_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004877 }
4878
Jeff Layton38d77c52013-05-26 07:01:00 -04004879 if (ses->server && ses->server->sign)
4880 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
Steve French1a4e15a2006-10-12 21:33:51 +00004881
Steve French50c2f752007-07-13 00:33:32 +00004882 pSMB->hdr.Uid = ses->Suid;
Steve French1a4e15a2006-10-12 21:33:51 +00004883
Linus Torvalds1da177e2005-04-16 15:20:36 -07004884 params = 2 /* level */ + name_len /*includes null */ ;
4885 pSMB->TotalDataCount = 0;
4886 pSMB->DataCount = 0;
4887 pSMB->DataOffset = 0;
4888 pSMB->MaxParameterCount = 0;
Steve French582d21e2008-05-13 04:54:12 +00004889 /* BB find exact max SMB PDU from sess structure BB */
4890 pSMB->MaxDataCount = cpu_to_le16(4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004891 pSMB->MaxSetupCount = 0;
4892 pSMB->Reserved = 0;
4893 pSMB->Flags = 0;
4894 pSMB->Timeout = 0;
4895 pSMB->Reserved2 = 0;
4896 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00004897 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004898 pSMB->SetupCount = 1;
4899 pSMB->Reserved3 = 0;
4900 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4901 byte_count = params + 3 /* pad */ ;
4902 pSMB->ParameterCount = cpu_to_le16(params);
4903 pSMB->TotalParameterCount = pSMB->ParameterCount;
4904 pSMB->MaxReferralLevel = cpu_to_le16(3);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004905 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004906 pSMB->ByteCount = cpu_to_le16(byte_count);
4907
4908 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4909 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4910 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004911 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004912 goto GetDFSRefExit;
4913 }
4914 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004915
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004916 /* BB Also check if enough total bytes returned? */
Jeff Layton820a8032011-05-04 08:05:26 -04004917 if (rc || get_bcc(&pSMBr->hdr) < 17) {
Steve Frenchc2cf07d2008-05-15 06:20:02 +00004918 rc = -EIO; /* bad smb */
Igor Mammedovfec45852008-05-16 13:06:30 +04004919 goto GetDFSRefExit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004920 }
Igor Mammedovfec45852008-05-16 13:06:30 +04004921
Joe Perchesf96637b2013-05-04 22:12:25 -05004922 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4923 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
Igor Mammedovfec45852008-05-16 13:06:30 +04004924
4925 /* parse returned result into more usable form */
Steve Frencha1fe78f2008-05-16 18:48:38 +00004926 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
Igor Mammedov2c556082008-10-23 13:58:42 +04004927 target_nodes, nls_codepage, remap,
Pavel Shilovskyb669f332012-05-27 20:21:53 +04004928 search_name);
Igor Mammedovfec45852008-05-16 13:06:30 +04004929
Linus Torvalds1da177e2005-04-16 15:20:36 -07004930GetDFSRefExit:
Steve French0d817bc2008-05-22 02:02:03 +00004931 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004932
4933 if (rc == -EAGAIN)
4934 goto getDFSRetry;
4935
4936 return rc;
4937}
4938
Steve French20962432005-09-21 22:05:57 -07004939/* Query File System Info such as free space to old servers such as Win 9x */
4940int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04004941SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4942 struct kstatfs *FSData)
Steve French20962432005-09-21 22:05:57 -07004943{
4944/* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4945 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4946 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4947 FILE_SYSTEM_ALLOC_INFO *response_data;
4948 int rc = 0;
4949 int bytes_returned = 0;
4950 __u16 params, byte_count;
4951
Joe Perchesf96637b2013-05-04 22:12:25 -05004952 cifs_dbg(FYI, "OldQFSInfo\n");
Steve French20962432005-09-21 22:05:57 -07004953oldQFSInfoRetry:
4954 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4955 (void **) &pSMBr);
4956 if (rc)
4957 return rc;
Steve French20962432005-09-21 22:05:57 -07004958
4959 params = 2; /* level */
4960 pSMB->TotalDataCount = 0;
4961 pSMB->MaxParameterCount = cpu_to_le16(2);
4962 pSMB->MaxDataCount = cpu_to_le16(1000);
4963 pSMB->MaxSetupCount = 0;
4964 pSMB->Reserved = 0;
4965 pSMB->Flags = 0;
4966 pSMB->Timeout = 0;
4967 pSMB->Reserved2 = 0;
4968 byte_count = params + 1 /* pad */ ;
4969 pSMB->TotalParameterCount = cpu_to_le16(params);
4970 pSMB->ParameterCount = pSMB->TotalParameterCount;
4971 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4972 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4973 pSMB->DataCount = 0;
4974 pSMB->DataOffset = 0;
4975 pSMB->SetupCount = 1;
4976 pSMB->Reserved3 = 0;
4977 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4978 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00004979 inc_rfc1001_len(pSMB, byte_count);
Steve French20962432005-09-21 22:05:57 -07004980 pSMB->ByteCount = cpu_to_le16(byte_count);
4981
4982 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4983 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4984 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05004985 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
Steve French20962432005-09-21 22:05:57 -07004986 } else { /* decode response */
4987 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4988
Jeff Layton820a8032011-05-04 08:05:26 -04004989 if (rc || get_bcc(&pSMBr->hdr) < 18)
Steve French20962432005-09-21 22:05:57 -07004990 rc = -EIO; /* bad smb */
4991 else {
4992 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Joe Perchesf96637b2013-05-04 22:12:25 -05004993 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n",
Jeff Layton820a8032011-05-04 08:05:26 -04004994 get_bcc(&pSMBr->hdr), data_offset);
Steve French20962432005-09-21 22:05:57 -07004995
Steve French50c2f752007-07-13 00:33:32 +00004996 response_data = (FILE_SYSTEM_ALLOC_INFO *)
Steve French20962432005-09-21 22:05:57 -07004997 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4998 FSData->f_bsize =
4999 le16_to_cpu(response_data->BytesPerSector) *
5000 le32_to_cpu(response_data->
5001 SectorsPerAllocationUnit);
5002 FSData->f_blocks =
Steve French50c2f752007-07-13 00:33:32 +00005003 le32_to_cpu(response_data->TotalAllocationUnits);
Steve French20962432005-09-21 22:05:57 -07005004 FSData->f_bfree = FSData->f_bavail =
5005 le32_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesf96637b2013-05-04 22:12:25 -05005006 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
5007 (unsigned long long)FSData->f_blocks,
5008 (unsigned long long)FSData->f_bfree,
5009 FSData->f_bsize);
Steve French20962432005-09-21 22:05:57 -07005010 }
5011 }
5012 cifs_buf_release(pSMB);
5013
5014 if (rc == -EAGAIN)
5015 goto oldQFSInfoRetry;
5016
5017 return rc;
5018}
5019
Linus Torvalds1da177e2005-04-16 15:20:36 -07005020int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005021CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
5022 struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005023{
5024/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5025 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5026 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5027 FILE_SYSTEM_INFO *response_data;
5028 int rc = 0;
5029 int bytes_returned = 0;
5030 __u16 params, byte_count;
5031
Joe Perchesf96637b2013-05-04 22:12:25 -05005032 cifs_dbg(FYI, "In QFSInfo\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005033QFSInfoRetry:
5034 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5035 (void **) &pSMBr);
5036 if (rc)
5037 return rc;
5038
5039 params = 2; /* level */
5040 pSMB->TotalDataCount = 0;
5041 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French20962432005-09-21 22:05:57 -07005042 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005043 pSMB->MaxSetupCount = 0;
5044 pSMB->Reserved = 0;
5045 pSMB->Flags = 0;
5046 pSMB->Timeout = 0;
5047 pSMB->Reserved2 = 0;
5048 byte_count = params + 1 /* pad */ ;
5049 pSMB->TotalParameterCount = cpu_to_le16(params);
5050 pSMB->ParameterCount = pSMB->TotalParameterCount;
5051 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005052 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005053 pSMB->DataCount = 0;
5054 pSMB->DataOffset = 0;
5055 pSMB->SetupCount = 1;
5056 pSMB->Reserved3 = 0;
5057 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5058 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005059 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005060 pSMB->ByteCount = cpu_to_le16(byte_count);
5061
5062 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5063 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5064 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005065 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005066 } else { /* decode response */
Steve French50c2f752007-07-13 00:33:32 +00005067 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005068
Jeff Layton820a8032011-05-04 08:05:26 -04005069 if (rc || get_bcc(&pSMBr->hdr) < 24)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005070 rc = -EIO; /* bad smb */
5071 else {
5072 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005073
5074 response_data =
5075 (FILE_SYSTEM_INFO
5076 *) (((char *) &pSMBr->hdr.Protocol) +
5077 data_offset);
5078 FSData->f_bsize =
5079 le32_to_cpu(response_data->BytesPerSector) *
5080 le32_to_cpu(response_data->
5081 SectorsPerAllocationUnit);
5082 FSData->f_blocks =
5083 le64_to_cpu(response_data->TotalAllocationUnits);
5084 FSData->f_bfree = FSData->f_bavail =
5085 le64_to_cpu(response_data->FreeAllocationUnits);
Joe Perchesf96637b2013-05-04 22:12:25 -05005086 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
5087 (unsigned long long)FSData->f_blocks,
5088 (unsigned long long)FSData->f_bfree,
5089 FSData->f_bsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005090 }
5091 }
5092 cifs_buf_release(pSMB);
5093
5094 if (rc == -EAGAIN)
5095 goto QFSInfoRetry;
5096
5097 return rc;
5098}
5099
5100int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005101CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005102{
5103/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5104 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5105 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5106 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5107 int rc = 0;
5108 int bytes_returned = 0;
5109 __u16 params, byte_count;
5110
Joe Perchesf96637b2013-05-04 22:12:25 -05005111 cifs_dbg(FYI, "In QFSAttributeInfo\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005112QFSAttributeRetry:
5113 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5114 (void **) &pSMBr);
5115 if (rc)
5116 return rc;
5117
5118 params = 2; /* level */
5119 pSMB->TotalDataCount = 0;
5120 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005121 /* BB find exact max SMB PDU from sess structure BB */
5122 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005123 pSMB->MaxSetupCount = 0;
5124 pSMB->Reserved = 0;
5125 pSMB->Flags = 0;
5126 pSMB->Timeout = 0;
5127 pSMB->Reserved2 = 0;
5128 byte_count = params + 1 /* pad */ ;
5129 pSMB->TotalParameterCount = cpu_to_le16(params);
5130 pSMB->ParameterCount = pSMB->TotalParameterCount;
5131 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005132 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005133 pSMB->DataCount = 0;
5134 pSMB->DataOffset = 0;
5135 pSMB->SetupCount = 1;
5136 pSMB->Reserved3 = 0;
5137 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5138 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005139 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005140 pSMB->ByteCount = cpu_to_le16(byte_count);
5141
5142 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5143 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5144 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005145 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005146 } else { /* decode response */
5147 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5148
Jeff Layton820a8032011-05-04 08:05:26 -04005149 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Steve French50c2f752007-07-13 00:33:32 +00005150 /* BB also check if enough bytes returned */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005151 rc = -EIO; /* bad smb */
5152 } else {
5153 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5154 response_data =
5155 (FILE_SYSTEM_ATTRIBUTE_INFO
5156 *) (((char *) &pSMBr->hdr.Protocol) +
5157 data_offset);
5158 memcpy(&tcon->fsAttrInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005159 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005160 }
5161 }
5162 cifs_buf_release(pSMB);
5163
5164 if (rc == -EAGAIN)
5165 goto QFSAttributeRetry;
5166
5167 return rc;
5168}
5169
5170int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005171CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005172{
5173/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5174 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5175 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5176 FILE_SYSTEM_DEVICE_INFO *response_data;
5177 int rc = 0;
5178 int bytes_returned = 0;
5179 __u16 params, byte_count;
5180
Joe Perchesf96637b2013-05-04 22:12:25 -05005181 cifs_dbg(FYI, "In QFSDeviceInfo\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005182QFSDeviceRetry:
5183 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5184 (void **) &pSMBr);
5185 if (rc)
5186 return rc;
5187
5188 params = 2; /* level */
5189 pSMB->TotalDataCount = 0;
5190 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005191 /* BB find exact max SMB PDU from sess structure BB */
5192 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005193 pSMB->MaxSetupCount = 0;
5194 pSMB->Reserved = 0;
5195 pSMB->Flags = 0;
5196 pSMB->Timeout = 0;
5197 pSMB->Reserved2 = 0;
5198 byte_count = params + 1 /* pad */ ;
5199 pSMB->TotalParameterCount = cpu_to_le16(params);
5200 pSMB->ParameterCount = pSMB->TotalParameterCount;
5201 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00005202 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005203
5204 pSMB->DataCount = 0;
5205 pSMB->DataOffset = 0;
5206 pSMB->SetupCount = 1;
5207 pSMB->Reserved3 = 0;
5208 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5209 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005210 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005211 pSMB->ByteCount = cpu_to_le16(byte_count);
5212
5213 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5214 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5215 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005216 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005217 } else { /* decode response */
5218 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5219
Jeff Layton820a8032011-05-04 08:05:26 -04005220 if (rc || get_bcc(&pSMBr->hdr) <
5221 sizeof(FILE_SYSTEM_DEVICE_INFO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005222 rc = -EIO; /* bad smb */
5223 else {
5224 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5225 response_data =
Steve French737b7582005-04-28 22:41:06 -07005226 (FILE_SYSTEM_DEVICE_INFO *)
5227 (((char *) &pSMBr->hdr.Protocol) +
Linus Torvalds1da177e2005-04-16 15:20:36 -07005228 data_offset);
5229 memcpy(&tcon->fsDevInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005230 sizeof(FILE_SYSTEM_DEVICE_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005231 }
5232 }
5233 cifs_buf_release(pSMB);
5234
5235 if (rc == -EAGAIN)
5236 goto QFSDeviceRetry;
5237
5238 return rc;
5239}
5240
5241int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005242CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005243{
5244/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5245 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5246 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5247 FILE_SYSTEM_UNIX_INFO *response_data;
5248 int rc = 0;
5249 int bytes_returned = 0;
5250 __u16 params, byte_count;
5251
Joe Perchesf96637b2013-05-04 22:12:25 -05005252 cifs_dbg(FYI, "In QFSUnixInfo\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005253QFSUnixRetry:
Jeff Laytonf5695992010-09-29 15:27:08 -04005254 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5255 (void **) &pSMB, (void **) &pSMBr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005256 if (rc)
5257 return rc;
5258
5259 params = 2; /* level */
5260 pSMB->TotalDataCount = 0;
5261 pSMB->DataCount = 0;
5262 pSMB->DataOffset = 0;
5263 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005264 /* BB find exact max SMB PDU from sess structure BB */
5265 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005266 pSMB->MaxSetupCount = 0;
5267 pSMB->Reserved = 0;
5268 pSMB->Flags = 0;
5269 pSMB->Timeout = 0;
5270 pSMB->Reserved2 = 0;
5271 byte_count = params + 1 /* pad */ ;
5272 pSMB->ParameterCount = cpu_to_le16(params);
5273 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005274 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5275 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005276 pSMB->SetupCount = 1;
5277 pSMB->Reserved3 = 0;
5278 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5279 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005280 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005281 pSMB->ByteCount = cpu_to_le16(byte_count);
5282
5283 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5284 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5285 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005286 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005287 } else { /* decode response */
5288 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5289
Jeff Layton820a8032011-05-04 08:05:26 -04005290 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005291 rc = -EIO; /* bad smb */
5292 } else {
5293 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5294 response_data =
5295 (FILE_SYSTEM_UNIX_INFO
5296 *) (((char *) &pSMBr->hdr.Protocol) +
5297 data_offset);
5298 memcpy(&tcon->fsUnixInfo, response_data,
Steve French26f57362007-08-30 22:09:15 +00005299 sizeof(FILE_SYSTEM_UNIX_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005300 }
5301 }
5302 cifs_buf_release(pSMB);
5303
5304 if (rc == -EAGAIN)
5305 goto QFSUnixRetry;
5306
5307
5308 return rc;
5309}
5310
Jeremy Allisonac670552005-06-22 17:26:35 -07005311int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005312CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
Jeremy Allisonac670552005-06-22 17:26:35 -07005313{
5314/* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5315 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5316 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5317 int rc = 0;
5318 int bytes_returned = 0;
5319 __u16 params, param_offset, offset, byte_count;
5320
Joe Perchesf96637b2013-05-04 22:12:25 -05005321 cifs_dbg(FYI, "In SETFSUnixInfo\n");
Jeremy Allisonac670552005-06-22 17:26:35 -07005322SETFSUnixRetry:
Steve Frenchf26282c2006-03-01 09:17:37 +00005323 /* BB switch to small buf init to save memory */
Jeff Laytonf5695992010-09-29 15:27:08 -04005324 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5325 (void **) &pSMB, (void **) &pSMBr);
Jeremy Allisonac670552005-06-22 17:26:35 -07005326 if (rc)
5327 return rc;
5328
5329 params = 4; /* 2 bytes zero followed by info level. */
5330 pSMB->MaxSetupCount = 0;
5331 pSMB->Reserved = 0;
5332 pSMB->Flags = 0;
5333 pSMB->Timeout = 0;
5334 pSMB->Reserved2 = 0;
Steve French50c2f752007-07-13 00:33:32 +00005335 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5336 - 4;
Jeremy Allisonac670552005-06-22 17:26:35 -07005337 offset = param_offset + params;
5338
5339 pSMB->MaxParameterCount = cpu_to_le16(4);
Steve French582d21e2008-05-13 04:54:12 +00005340 /* BB find exact max SMB PDU from sess structure BB */
5341 pSMB->MaxDataCount = cpu_to_le16(100);
Jeremy Allisonac670552005-06-22 17:26:35 -07005342 pSMB->SetupCount = 1;
5343 pSMB->Reserved3 = 0;
5344 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5345 byte_count = 1 /* pad */ + params + 12;
5346
5347 pSMB->DataCount = cpu_to_le16(12);
5348 pSMB->ParameterCount = cpu_to_le16(params);
5349 pSMB->TotalDataCount = pSMB->DataCount;
5350 pSMB->TotalParameterCount = pSMB->ParameterCount;
5351 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5352 pSMB->DataOffset = cpu_to_le16(offset);
5353
5354 /* Params. */
5355 pSMB->FileNum = 0;
5356 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5357
5358 /* Data. */
5359 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5360 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5361 pSMB->ClientUnixCap = cpu_to_le64(cap);
5362
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005363 inc_rfc1001_len(pSMB, byte_count);
Jeremy Allisonac670552005-06-22 17:26:35 -07005364 pSMB->ByteCount = cpu_to_le16(byte_count);
5365
5366 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5367 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5368 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005369 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
Jeremy Allisonac670552005-06-22 17:26:35 -07005370 } else { /* decode response */
5371 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Steve Frenchad7a2922008-02-07 23:25:02 +00005372 if (rc)
Jeremy Allisonac670552005-06-22 17:26:35 -07005373 rc = -EIO; /* bad smb */
Jeremy Allisonac670552005-06-22 17:26:35 -07005374 }
5375 cifs_buf_release(pSMB);
5376
5377 if (rc == -EAGAIN)
5378 goto SETFSUnixRetry;
5379
5380 return rc;
5381}
5382
5383
Linus Torvalds1da177e2005-04-16 15:20:36 -07005384
5385int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005386CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
Steve French737b7582005-04-28 22:41:06 -07005387 struct kstatfs *FSData)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005388{
5389/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5390 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5391 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5392 FILE_SYSTEM_POSIX_INFO *response_data;
5393 int rc = 0;
5394 int bytes_returned = 0;
5395 __u16 params, byte_count;
5396
Joe Perchesf96637b2013-05-04 22:12:25 -05005397 cifs_dbg(FYI, "In QFSPosixInfo\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005398QFSPosixRetry:
5399 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5400 (void **) &pSMBr);
5401 if (rc)
5402 return rc;
5403
5404 params = 2; /* level */
5405 pSMB->TotalDataCount = 0;
5406 pSMB->DataCount = 0;
5407 pSMB->DataOffset = 0;
5408 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005409 /* BB find exact max SMB PDU from sess structure BB */
5410 pSMB->MaxDataCount = cpu_to_le16(100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005411 pSMB->MaxSetupCount = 0;
5412 pSMB->Reserved = 0;
5413 pSMB->Flags = 0;
5414 pSMB->Timeout = 0;
5415 pSMB->Reserved2 = 0;
5416 byte_count = params + 1 /* pad */ ;
5417 pSMB->ParameterCount = cpu_to_le16(params);
5418 pSMB->TotalParameterCount = pSMB->ParameterCount;
Steve French50c2f752007-07-13 00:33:32 +00005419 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5420 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005421 pSMB->SetupCount = 1;
5422 pSMB->Reserved3 = 0;
5423 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5424 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005425 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005426 pSMB->ByteCount = cpu_to_le16(byte_count);
5427
5428 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5429 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5430 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005431 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005432 } else { /* decode response */
5433 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5434
Jeff Layton820a8032011-05-04 08:05:26 -04005435 if (rc || get_bcc(&pSMBr->hdr) < 13) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005436 rc = -EIO; /* bad smb */
5437 } else {
5438 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5439 response_data =
5440 (FILE_SYSTEM_POSIX_INFO
5441 *) (((char *) &pSMBr->hdr.Protocol) +
5442 data_offset);
5443 FSData->f_bsize =
5444 le32_to_cpu(response_data->BlockSize);
5445 FSData->f_blocks =
5446 le64_to_cpu(response_data->TotalBlocks);
5447 FSData->f_bfree =
5448 le64_to_cpu(response_data->BlocksAvail);
Steve French790fe572007-07-07 19:25:05 +00005449 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005450 FSData->f_bavail = FSData->f_bfree;
5451 } else {
5452 FSData->f_bavail =
Steve French50c2f752007-07-13 00:33:32 +00005453 le64_to_cpu(response_data->UserBlocksAvail);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005454 }
Steve French790fe572007-07-07 19:25:05 +00005455 if (response_data->TotalFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005456 FSData->f_files =
Steve French50c2f752007-07-13 00:33:32 +00005457 le64_to_cpu(response_data->TotalFileNodes);
Steve French790fe572007-07-07 19:25:05 +00005458 if (response_data->FreeFileNodes != cpu_to_le64(-1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07005459 FSData->f_ffree =
Steve French50c2f752007-07-13 00:33:32 +00005460 le64_to_cpu(response_data->FreeFileNodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005461 }
5462 }
5463 cifs_buf_release(pSMB);
5464
5465 if (rc == -EAGAIN)
5466 goto QFSPosixRetry;
5467
5468 return rc;
5469}
5470
5471
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005472/*
5473 * We can not use write of zero bytes trick to set file size due to need for
5474 * large file support. Also note that this SetPathInfo is preferred to
5475 * SetFileInfo based method in next routine which is only needed to work around
5476 * a sharing violation bugin Samba which this routine can run into.
5477 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005478int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005479CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005480 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
5481 bool set_allocation)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005482{
5483 struct smb_com_transaction2_spi_req *pSMB = NULL;
5484 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5485 struct file_end_of_file_info *parm_data;
5486 int name_len;
5487 int rc = 0;
5488 int bytes_returned = 0;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005489 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
5490
Linus Torvalds1da177e2005-04-16 15:20:36 -07005491 __u16 params, byte_count, data_count, param_offset, offset;
5492
Joe Perchesf96637b2013-05-04 22:12:25 -05005493 cifs_dbg(FYI, "In SetEOF\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005494SetEOFRetry:
5495 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5496 (void **) &pSMBr);
5497 if (rc)
5498 return rc;
5499
5500 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5501 name_len =
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005502 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5503 PATH_MAX, cifs_sb->local_nls, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005504 name_len++; /* trailing null */
5505 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07005506 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005507 name_len = strnlen(file_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005508 name_len++; /* trailing null */
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005509 strncpy(pSMB->FileName, file_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005510 }
5511 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005512 data_count = sizeof(struct file_end_of_file_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005513 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French3e87d802005-09-18 20:49:21 -07005514 pSMB->MaxDataCount = cpu_to_le16(4100);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005515 pSMB->MaxSetupCount = 0;
5516 pSMB->Reserved = 0;
5517 pSMB->Flags = 0;
5518 pSMB->Timeout = 0;
5519 pSMB->Reserved2 = 0;
5520 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005521 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005522 offset = param_offset + params;
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005523 if (set_allocation) {
Steve French50c2f752007-07-13 00:33:32 +00005524 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5525 pSMB->InformationLevel =
5526 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5527 else
5528 pSMB->InformationLevel =
5529 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5530 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005531 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5532 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005533 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005534 else
5535 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005536 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005537 }
5538
5539 parm_data =
5540 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5541 offset);
5542 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5543 pSMB->DataOffset = cpu_to_le16(offset);
5544 pSMB->SetupCount = 1;
5545 pSMB->Reserved3 = 0;
5546 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5547 byte_count = 3 /* pad */ + params + data_count;
5548 pSMB->DataCount = cpu_to_le16(data_count);
5549 pSMB->TotalDataCount = pSMB->DataCount;
5550 pSMB->ParameterCount = cpu_to_le16(params);
5551 pSMB->TotalParameterCount = pSMB->ParameterCount;
5552 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005553 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005554 parm_data->FileSize = cpu_to_le64(size);
5555 pSMB->ByteCount = cpu_to_le16(byte_count);
5556 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5557 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005558 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05005559 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005560
5561 cifs_buf_release(pSMB);
5562
5563 if (rc == -EAGAIN)
5564 goto SetEOFRetry;
5565
5566 return rc;
5567}
5568
5569int
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005570CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5571 struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005572{
5573 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005574 struct file_end_of_file_info *parm_data;
5575 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005576 __u16 params, param_offset, offset, byte_count, count;
5577
Joe Perchesf96637b2013-05-04 22:12:25 -05005578 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5579 (long long)size);
Steve Frenchcd634992005-04-28 22:41:10 -07005580 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5581
Linus Torvalds1da177e2005-04-16 15:20:36 -07005582 if (rc)
5583 return rc;
5584
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005585 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5586 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005587
Linus Torvalds1da177e2005-04-16 15:20:36 -07005588 params = 6;
5589 pSMB->MaxSetupCount = 0;
5590 pSMB->Reserved = 0;
5591 pSMB->Flags = 0;
5592 pSMB->Timeout = 0;
5593 pSMB->Reserved2 = 0;
5594 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5595 offset = param_offset + params;
5596
Linus Torvalds1da177e2005-04-16 15:20:36 -07005597 count = sizeof(struct file_end_of_file_info);
5598 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005599 /* BB find exact max SMB PDU from sess structure BB */
5600 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005601 pSMB->SetupCount = 1;
5602 pSMB->Reserved3 = 0;
5603 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5604 byte_count = 3 /* pad */ + params + count;
5605 pSMB->DataCount = cpu_to_le16(count);
5606 pSMB->ParameterCount = cpu_to_le16(params);
5607 pSMB->TotalDataCount = pSMB->DataCount;
5608 pSMB->TotalParameterCount = pSMB->ParameterCount;
5609 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5610 parm_data =
Steve French50c2f752007-07-13 00:33:32 +00005611 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5612 + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005613 pSMB->DataOffset = cpu_to_le16(offset);
5614 parm_data->FileSize = cpu_to_le64(size);
Pavel Shilovskyd1433412012-09-18 16:20:31 -07005615 pSMB->Fid = cfile->fid.netfid;
5616 if (set_allocation) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005617 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5618 pSMB->InformationLevel =
5619 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5620 else
5621 pSMB->InformationLevel =
5622 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
Steve French50c2f752007-07-13 00:33:32 +00005623 } else /* Set File Size */ {
Linus Torvalds1da177e2005-04-16 15:20:36 -07005624 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5625 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005626 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005627 else
5628 pSMB->InformationLevel =
Steve French50c2f752007-07-13 00:33:32 +00005629 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005630 }
5631 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005632 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005633 pSMB->ByteCount = cpu_to_le16(byte_count);
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005634 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005635 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05005636 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5637 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005638 }
5639
Steve French50c2f752007-07-13 00:33:32 +00005640 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005641 since file handle passed in no longer valid */
5642
5643 return rc;
5644}
5645
Steve French50c2f752007-07-13 00:33:32 +00005646/* Some legacy servers such as NT4 require that the file times be set on
Linus Torvalds1da177e2005-04-16 15:20:36 -07005647 an open handle, rather than by pathname - this is awkward due to
5648 potential access conflicts on the open, but it is unavoidable for these
5649 old servers since the only other choice is to go from 100 nanosecond DCE
5650 time and resort to the original setpathinfo level which takes the ancient
5651 DOS time format with 2 second granularity */
5652int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005653CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005654 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005655{
5656 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005657 char *data_offset;
5658 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005659 __u16 params, param_offset, offset, byte_count, count;
5660
Joe Perchesf96637b2013-05-04 22:12:25 -05005661 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
Steve Frenchcd634992005-04-28 22:41:10 -07005662 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5663
Linus Torvalds1da177e2005-04-16 15:20:36 -07005664 if (rc)
5665 return rc;
5666
Jeff Layton2dd2dfa2008-08-02 07:26:12 -04005667 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5668 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
Steve French50c2f752007-07-13 00:33:32 +00005669
Linus Torvalds1da177e2005-04-16 15:20:36 -07005670 params = 6;
5671 pSMB->MaxSetupCount = 0;
5672 pSMB->Reserved = 0;
5673 pSMB->Flags = 0;
5674 pSMB->Timeout = 0;
5675 pSMB->Reserved2 = 0;
5676 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5677 offset = param_offset + params;
5678
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04005679 data_offset = (char *)pSMB +
5680 offsetof(struct smb_hdr, Protocol) + offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005681
Steve French26f57362007-08-30 22:09:15 +00005682 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005683 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005684 /* BB find max SMB PDU from sess */
5685 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005686 pSMB->SetupCount = 1;
5687 pSMB->Reserved3 = 0;
5688 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5689 byte_count = 3 /* pad */ + params + count;
5690 pSMB->DataCount = cpu_to_le16(count);
5691 pSMB->ParameterCount = cpu_to_le16(params);
5692 pSMB->TotalDataCount = pSMB->DataCount;
5693 pSMB->TotalParameterCount = pSMB->ParameterCount;
5694 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5695 pSMB->DataOffset = cpu_to_le16(offset);
5696 pSMB->Fid = fid;
5697 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5698 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5699 else
5700 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5701 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005702 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005703 pSMB->ByteCount = cpu_to_le16(byte_count);
Steve French50c2f752007-07-13 00:33:32 +00005704 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005705 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005706 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05005707 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5708 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005709
Steve French50c2f752007-07-13 00:33:32 +00005710 /* Note: On -EAGAIN error only caller can retry on handle based calls
Linus Torvalds1da177e2005-04-16 15:20:36 -07005711 since file handle passed in no longer valid */
5712
5713 return rc;
5714}
5715
Jeff Layton6d22f092008-09-23 11:48:35 -04005716int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005717CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton6d22f092008-09-23 11:48:35 -04005718 bool delete_file, __u16 fid, __u32 pid_of_opener)
5719{
5720 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5721 char *data_offset;
5722 int rc = 0;
5723 __u16 params, param_offset, offset, byte_count, count;
5724
Joe Perchesf96637b2013-05-04 22:12:25 -05005725 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
Jeff Layton6d22f092008-09-23 11:48:35 -04005726 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5727
5728 if (rc)
5729 return rc;
5730
5731 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5732 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5733
5734 params = 6;
5735 pSMB->MaxSetupCount = 0;
5736 pSMB->Reserved = 0;
5737 pSMB->Flags = 0;
5738 pSMB->Timeout = 0;
5739 pSMB->Reserved2 = 0;
5740 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5741 offset = param_offset + params;
5742
5743 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5744
5745 count = 1;
5746 pSMB->MaxParameterCount = cpu_to_le16(2);
5747 /* BB find max SMB PDU from sess */
5748 pSMB->MaxDataCount = cpu_to_le16(1000);
5749 pSMB->SetupCount = 1;
5750 pSMB->Reserved3 = 0;
5751 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5752 byte_count = 3 /* pad */ + params + count;
5753 pSMB->DataCount = cpu_to_le16(count);
5754 pSMB->ParameterCount = cpu_to_le16(params);
5755 pSMB->TotalDataCount = pSMB->DataCount;
5756 pSMB->TotalParameterCount = pSMB->ParameterCount;
5757 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5758 pSMB->DataOffset = cpu_to_le16(offset);
5759 pSMB->Fid = fid;
5760 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5761 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005762 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton6d22f092008-09-23 11:48:35 -04005763 pSMB->ByteCount = cpu_to_le16(byte_count);
5764 *data_offset = delete_file ? 1 : 0;
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04005765 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Jeff Layton6d22f092008-09-23 11:48:35 -04005766 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05005767 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
Jeff Layton6d22f092008-09-23 11:48:35 -04005768
5769 return rc;
5770}
Linus Torvalds1da177e2005-04-16 15:20:36 -07005771
5772int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005773CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton6fc000e2008-08-02 07:26:12 -04005774 const char *fileName, const FILE_BASIC_INFO *data,
5775 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005776{
5777 TRANSACTION2_SPI_REQ *pSMB = NULL;
5778 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5779 int name_len;
5780 int rc = 0;
5781 int bytes_returned = 0;
5782 char *data_offset;
5783 __u16 params, param_offset, offset, byte_count, count;
5784
Joe Perchesf96637b2013-05-04 22:12:25 -05005785 cifs_dbg(FYI, "In SetTimes\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005786
5787SetTimesRetry:
5788 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5789 (void **) &pSMBr);
5790 if (rc)
5791 return rc;
5792
5793 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5794 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06005795 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5796 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005797 name_len++; /* trailing null */
5798 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005799 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005800 name_len = strnlen(fileName, PATH_MAX);
5801 name_len++; /* trailing null */
5802 strncpy(pSMB->FileName, fileName, name_len);
5803 }
5804
5805 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00005806 count = sizeof(FILE_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005807 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00005808 /* BB find max SMB PDU from sess structure BB */
5809 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005810 pSMB->MaxSetupCount = 0;
5811 pSMB->Reserved = 0;
5812 pSMB->Flags = 0;
5813 pSMB->Timeout = 0;
5814 pSMB->Reserved2 = 0;
5815 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00005816 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07005817 offset = param_offset + params;
5818 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5819 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5820 pSMB->DataOffset = cpu_to_le16(offset);
5821 pSMB->SetupCount = 1;
5822 pSMB->Reserved3 = 0;
5823 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5824 byte_count = 3 /* pad */ + params + count;
5825
5826 pSMB->DataCount = cpu_to_le16(count);
5827 pSMB->ParameterCount = cpu_to_le16(params);
5828 pSMB->TotalDataCount = pSMB->DataCount;
5829 pSMB->TotalParameterCount = pSMB->ParameterCount;
5830 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5831 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5832 else
5833 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5834 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005835 inc_rfc1001_len(pSMB, byte_count);
Steve French26f57362007-08-30 22:09:15 +00005836 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
Linus Torvalds1da177e2005-04-16 15:20:36 -07005837 pSMB->ByteCount = cpu_to_le16(byte_count);
5838 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5839 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005840 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05005841 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005842
5843 cifs_buf_release(pSMB);
5844
5845 if (rc == -EAGAIN)
5846 goto SetTimesRetry;
5847
5848 return rc;
5849}
5850
5851/* Can not be used to set time stamps yet (due to old DOS time format) */
5852/* Can be used to set attributes */
5853#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5854 handling it anyway and NT4 was what we thought it would be needed for
5855 Do not delete it until we prove whether needed for Win9x though */
5856int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005857CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon, char *fileName,
Linus Torvalds1da177e2005-04-16 15:20:36 -07005858 __u16 dos_attrs, const struct nls_table *nls_codepage)
5859{
5860 SETATTR_REQ *pSMB = NULL;
5861 SETATTR_RSP *pSMBr = NULL;
5862 int rc = 0;
5863 int bytes_returned;
5864 int name_len;
5865
Joe Perchesf96637b2013-05-04 22:12:25 -05005866 cifs_dbg(FYI, "In SetAttrLegacy\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07005867
5868SetAttrLgcyRetry:
5869 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5870 (void **) &pSMBr);
5871 if (rc)
5872 return rc;
5873
5874 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5875 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06005876 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5877 PATH_MAX, nls_codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005878 name_len++; /* trailing null */
5879 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00005880 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005881 name_len = strnlen(fileName, PATH_MAX);
5882 name_len++; /* trailing null */
5883 strncpy(pSMB->fileName, fileName, name_len);
5884 }
5885 pSMB->attr = cpu_to_le16(dos_attrs);
5886 pSMB->BufferFormat = 0x04;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005887 inc_rfc1001_len(pSMB, name_len + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005888 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5889 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5890 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00005891 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05005892 cifs_dbg(FYI, "Error in LegacySetAttr = %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07005893
5894 cifs_buf_release(pSMB);
5895
5896 if (rc == -EAGAIN)
5897 goto SetAttrLgcyRetry;
5898
5899 return rc;
5900}
5901#endif /* temporarily unneeded SetAttr legacy function */
5902
Jeff Layton654cf142009-07-09 20:02:49 -04005903static void
5904cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5905 const struct cifs_unix_set_info_args *args)
5906{
Eric W. Biederman49418b22013-02-06 00:57:56 -08005907 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
Jeff Layton654cf142009-07-09 20:02:49 -04005908 u64 mode = args->mode;
5909
Eric W. Biederman49418b22013-02-06 00:57:56 -08005910 if (uid_valid(args->uid))
5911 uid = from_kuid(&init_user_ns, args->uid);
5912 if (gid_valid(args->gid))
5913 gid = from_kgid(&init_user_ns, args->gid);
5914
Jeff Layton654cf142009-07-09 20:02:49 -04005915 /*
5916 * Samba server ignores set of file size to zero due to bugs in some
5917 * older clients, but we should be precise - we use SetFileSize to
5918 * set file size and do not want to truncate file size to zero
Lucas De Marchi25985ed2011-03-30 22:57:33 -03005919 * accidentally as happened on one Samba server beta by putting
Jeff Layton654cf142009-07-09 20:02:49 -04005920 * zero instead of -1 here
5921 */
5922 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5923 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5924 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5925 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5926 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
Eric W. Biederman49418b22013-02-06 00:57:56 -08005927 data_offset->Uid = cpu_to_le64(uid);
5928 data_offset->Gid = cpu_to_le64(gid);
Jeff Layton654cf142009-07-09 20:02:49 -04005929 /* better to leave device as zero when it is */
5930 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5931 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5932 data_offset->Permissions = cpu_to_le64(mode);
5933
5934 if (S_ISREG(mode))
5935 data_offset->Type = cpu_to_le32(UNIX_FILE);
5936 else if (S_ISDIR(mode))
5937 data_offset->Type = cpu_to_le32(UNIX_DIR);
5938 else if (S_ISLNK(mode))
5939 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5940 else if (S_ISCHR(mode))
5941 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5942 else if (S_ISBLK(mode))
5943 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5944 else if (S_ISFIFO(mode))
5945 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5946 else if (S_ISSOCK(mode))
5947 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5948}
5949
Linus Torvalds1da177e2005-04-16 15:20:36 -07005950int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04005951CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005952 const struct cifs_unix_set_info_args *args,
5953 u16 fid, u32 pid_of_opener)
5954{
5955 struct smb_com_transaction2_sfi_req *pSMB = NULL;
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04005956 char *data_offset;
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005957 int rc = 0;
5958 u16 params, param_offset, offset, byte_count, count;
5959
Joe Perchesf96637b2013-05-04 22:12:25 -05005960 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005961 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5962
5963 if (rc)
5964 return rc;
5965
5966 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5967 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5968
5969 params = 6;
5970 pSMB->MaxSetupCount = 0;
5971 pSMB->Reserved = 0;
5972 pSMB->Flags = 0;
5973 pSMB->Timeout = 0;
5974 pSMB->Reserved2 = 0;
5975 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5976 offset = param_offset + params;
5977
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04005978 data_offset = (char *)pSMB +
5979 offsetof(struct smb_hdr, Protocol) + offset;
5980
Jeff Layton3bbeeb32009-07-09 20:02:50 -04005981 count = sizeof(FILE_UNIX_BASIC_INFO);
5982
5983 pSMB->MaxParameterCount = cpu_to_le16(2);
5984 /* BB find max SMB PDU from sess */
5985 pSMB->MaxDataCount = cpu_to_le16(1000);
5986 pSMB->SetupCount = 1;
5987 pSMB->Reserved3 = 0;
5988 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5989 byte_count = 3 /* pad */ + params + count;
5990 pSMB->DataCount = cpu_to_le16(count);
5991 pSMB->ParameterCount = cpu_to_le16(params);
5992 pSMB->TotalDataCount = pSMB->DataCount;
5993 pSMB->TotalParameterCount = pSMB->ParameterCount;
5994 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5995 pSMB->DataOffset = cpu_to_le16(offset);
5996 pSMB->Fid = fid;
5997 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5998 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00005999 inc_rfc1001_len(pSMB, byte_count);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006000 pSMB->ByteCount = cpu_to_le16(byte_count);
6001
Jeff Laytonb2a3ad92012-03-26 09:55:29 -04006002 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006003
Pavel Shilovsky792af7b2012-03-23 14:28:02 -04006004 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006005 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05006006 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
6007 rc);
Jeff Layton3bbeeb32009-07-09 20:02:50 -04006008
6009 /* Note: On -EAGAIN error only caller can retry on handle based calls
6010 since file handle passed in no longer valid */
6011
6012 return rc;
6013}
6014
6015int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04006016CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
Pavel Shilovskyff691e92012-07-13 14:04:46 +04006017 const char *file_name,
Jeff Layton01ea95e2009-07-09 20:02:49 -04006018 const struct cifs_unix_set_info_args *args,
6019 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006020{
6021 TRANSACTION2_SPI_REQ *pSMB = NULL;
6022 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6023 int name_len;
6024 int rc = 0;
6025 int bytes_returned = 0;
6026 FILE_UNIX_BASIC_INFO *data_offset;
6027 __u16 params, param_offset, offset, count, byte_count;
6028
Joe Perchesf96637b2013-05-04 22:12:25 -05006029 cifs_dbg(FYI, "In SetUID/GID/Mode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006030setPermsRetry:
6031 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6032 (void **) &pSMBr);
6033 if (rc)
6034 return rc;
6035
6036 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6037 name_len =
Pavel Shilovskyff691e92012-07-13 14:04:46 +04006038 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
Steve Frenchacbbb762012-01-18 22:32:33 -06006039 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006040 name_len++; /* trailing null */
6041 name_len *= 2;
Steve French3e87d802005-09-18 20:49:21 -07006042 } else { /* BB improve the check for buffer overruns BB */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04006043 name_len = strnlen(file_name, PATH_MAX);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006044 name_len++; /* trailing null */
Pavel Shilovskyff691e92012-07-13 14:04:46 +04006045 strncpy(pSMB->FileName, file_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006046 }
6047
6048 params = 6 + name_len;
Steve French26f57362007-08-30 22:09:15 +00006049 count = sizeof(FILE_UNIX_BASIC_INFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006050 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006051 /* BB find max SMB PDU from sess structure BB */
6052 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006053 pSMB->MaxSetupCount = 0;
6054 pSMB->Reserved = 0;
6055 pSMB->Flags = 0;
6056 pSMB->Timeout = 0;
6057 pSMB->Reserved2 = 0;
6058 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006059 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006060 offset = param_offset + params;
6061 data_offset =
6062 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6063 offset);
6064 memset(data_offset, 0, count);
6065 pSMB->DataOffset = cpu_to_le16(offset);
6066 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6067 pSMB->SetupCount = 1;
6068 pSMB->Reserved3 = 0;
6069 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6070 byte_count = 3 /* pad */ + params + count;
6071 pSMB->ParameterCount = cpu_to_le16(params);
6072 pSMB->DataCount = cpu_to_le16(count);
6073 pSMB->TotalParameterCount = pSMB->ParameterCount;
6074 pSMB->TotalDataCount = pSMB->DataCount;
6075 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6076 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006077 inc_rfc1001_len(pSMB, byte_count);
Steve French50c2f752007-07-13 00:33:32 +00006078
Jeff Layton654cf142009-07-09 20:02:49 -04006079 cifs_fill_unix_set_info(data_offset, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006080
6081 pSMB->ByteCount = cpu_to_le16(byte_count);
6082 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6083 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006084 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05006085 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006086
Steve French0d817bc2008-05-22 02:02:03 +00006087 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006088 if (rc == -EAGAIN)
6089 goto setPermsRetry;
6090 return rc;
6091}
6092
Linus Torvalds1da177e2005-04-16 15:20:36 -07006093#ifdef CONFIG_CIFS_XATTR
Jeff Layton31c05192010-02-10 16:18:26 -05006094/*
6095 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6096 * function used by listxattr and getxattr type calls. When ea_name is set,
6097 * it looks for that attribute name and stuffs that value into the EAData
6098 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6099 * buffer. In both cases, the return value is either the length of the
6100 * resulting data or a negative error code. If EAData is a NULL pointer then
6101 * the data isn't copied to it, but the length is returned.
6102 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006103ssize_t
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04006104CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
Jeff Layton31c05192010-02-10 16:18:26 -05006105 const unsigned char *searchName, const unsigned char *ea_name,
6106 char *EAData, size_t buf_size,
6107 const struct nls_table *nls_codepage, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006108{
6109 /* BB assumes one setup word */
6110 TRANSACTION2_QPI_REQ *pSMB = NULL;
6111 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6112 int rc = 0;
6113 int bytes_returned;
Jeff Layton6e462b92010-02-10 16:18:26 -05006114 int list_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006115 struct fealist *ea_response_data;
Steve French50c2f752007-07-13 00:33:32 +00006116 struct fea *temp_fea;
6117 char *temp_ptr;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006118 char *end_of_smb;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006119 __u16 params, byte_count, data_offset;
Jeff Layton5980fc92011-07-28 12:48:26 -04006120 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006121
Joe Perchesf96637b2013-05-04 22:12:25 -05006122 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006123QAllEAsRetry:
6124 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6125 (void **) &pSMBr);
6126 if (rc)
6127 return rc;
6128
6129 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
Jeff Layton6e462b92010-02-10 16:18:26 -05006130 list_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06006131 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6132 PATH_MAX, nls_codepage, remap);
Jeff Layton6e462b92010-02-10 16:18:26 -05006133 list_len++; /* trailing null */
6134 list_len *= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006135 } else { /* BB improve the check for buffer overruns BB */
Jeff Layton6e462b92010-02-10 16:18:26 -05006136 list_len = strnlen(searchName, PATH_MAX);
6137 list_len++; /* trailing null */
6138 strncpy(pSMB->FileName, searchName, list_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006139 }
6140
Jeff Layton6e462b92010-02-10 16:18:26 -05006141 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006142 pSMB->TotalDataCount = 0;
6143 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006144 /* BB find exact max SMB PDU from sess structure BB */
Jeff Laytone5296142010-02-10 16:18:26 -05006145 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006146 pSMB->MaxSetupCount = 0;
6147 pSMB->Reserved = 0;
6148 pSMB->Flags = 0;
6149 pSMB->Timeout = 0;
6150 pSMB->Reserved2 = 0;
6151 pSMB->ParameterOffset = cpu_to_le16(offsetof(
Steve French50c2f752007-07-13 00:33:32 +00006152 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006153 pSMB->DataCount = 0;
6154 pSMB->DataOffset = 0;
6155 pSMB->SetupCount = 1;
6156 pSMB->Reserved3 = 0;
6157 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6158 byte_count = params + 1 /* pad */ ;
6159 pSMB->TotalParameterCount = cpu_to_le16(params);
6160 pSMB->ParameterCount = pSMB->TotalParameterCount;
6161 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6162 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006163 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006164 pSMB->ByteCount = cpu_to_le16(byte_count);
6165
6166 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6167 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6168 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006169 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
Jeff Laytonf0d38682010-02-10 16:18:26 -05006170 goto QAllEAsOut;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006171 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006172
6173
6174 /* BB also check enough total bytes returned */
6175 /* BB we need to improve the validity checking
6176 of these trans2 responses */
6177
6178 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
Jeff Layton820a8032011-05-04 08:05:26 -04006179 if (rc || get_bcc(&pSMBr->hdr) < 4) {
Jeff Laytonf0d38682010-02-10 16:18:26 -05006180 rc = -EIO; /* bad smb */
6181 goto QAllEAsOut;
6182 }
6183
6184 /* check that length of list is not more than bcc */
6185 /* check that each entry does not go beyond length
6186 of list */
6187 /* check that each element of each entry does not
6188 go beyond end of list */
6189 /* validate_trans2_offsets() */
6190 /* BB check if start of smb + data_offset > &bcc+ bcc */
6191
6192 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6193 ea_response_data = (struct fealist *)
6194 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6195
Jeff Layton6e462b92010-02-10 16:18:26 -05006196 list_len = le32_to_cpu(ea_response_data->list_len);
Joe Perchesf96637b2013-05-04 22:12:25 -05006197 cifs_dbg(FYI, "ea length %d\n", list_len);
Jeff Layton6e462b92010-02-10 16:18:26 -05006198 if (list_len <= 8) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006199 cifs_dbg(FYI, "empty EA list returned from server\n");
Steve French60977fc2014-03-25 19:46:36 -05006200 /* didn't find the named attribute */
6201 if (ea_name)
6202 rc = -ENODATA;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006203 goto QAllEAsOut;
6204 }
6205
Jeff Layton0cd126b2010-02-10 16:18:26 -05006206 /* make sure list_len doesn't go past end of SMB */
Jeff Layton690c5222011-01-20 13:36:51 -05006207 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
Jeff Layton0cd126b2010-02-10 16:18:26 -05006208 if ((char *)ea_response_data + list_len > end_of_smb) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006209 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006210 rc = -EIO;
6211 goto QAllEAsOut;
6212 }
6213
Jeff Laytonf0d38682010-02-10 16:18:26 -05006214 /* account for ea list len */
Jeff Layton6e462b92010-02-10 16:18:26 -05006215 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006216 temp_fea = ea_response_data->list;
6217 temp_ptr = (char *)temp_fea;
Jeff Layton6e462b92010-02-10 16:18:26 -05006218 while (list_len > 0) {
Steve French122ca002010-02-24 21:56:48 +00006219 unsigned int name_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006220 __u16 value_len;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006221
Jeff Layton6e462b92010-02-10 16:18:26 -05006222 list_len -= 4;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006223 temp_ptr += 4;
Jeff Layton0cd126b2010-02-10 16:18:26 -05006224 /* make sure we can read name_len and value_len */
6225 if (list_len < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006226 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006227 rc = -EIO;
6228 goto QAllEAsOut;
6229 }
6230
6231 name_len = temp_fea->name_len;
6232 value_len = le16_to_cpu(temp_fea->value_len);
6233 list_len -= name_len + 1 + value_len;
6234 if (list_len < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006235 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
Jeff Layton0cd126b2010-02-10 16:18:26 -05006236 rc = -EIO;
6237 goto QAllEAsOut;
6238 }
6239
Jeff Layton31c05192010-02-10 16:18:26 -05006240 if (ea_name) {
Jeff Layton91d065c2011-07-26 18:23:47 -04006241 if (ea_name_len == name_len &&
Jeff Laytonac423442011-10-11 06:41:32 -04006242 memcmp(ea_name, temp_ptr, name_len) == 0) {
Jeff Layton31c05192010-02-10 16:18:26 -05006243 temp_ptr += name_len + 1;
6244 rc = value_len;
6245 if (buf_size == 0)
6246 goto QAllEAsOut;
6247 if ((size_t)value_len > buf_size) {
6248 rc = -ERANGE;
6249 goto QAllEAsOut;
6250 }
6251 memcpy(EAData, temp_ptr, value_len);
6252 goto QAllEAsOut;
6253 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006254 } else {
Jeff Layton31c05192010-02-10 16:18:26 -05006255 /* account for prefix user. and trailing null */
6256 rc += (5 + 1 + name_len);
6257 if (rc < (int) buf_size) {
6258 memcpy(EAData, "user.", 5);
6259 EAData += 5;
6260 memcpy(EAData, temp_ptr, name_len);
6261 EAData += name_len;
6262 /* null terminate name */
6263 *EAData = 0;
6264 ++EAData;
6265 } else if (buf_size == 0) {
6266 /* skip copy - calc size only */
6267 } else {
6268 /* stop before overrun buffer */
6269 rc = -ERANGE;
6270 break;
6271 }
Jeff Laytonf0d38682010-02-10 16:18:26 -05006272 }
Jeff Layton0cd126b2010-02-10 16:18:26 -05006273 temp_ptr += name_len + 1 + value_len;
Jeff Laytonf0d38682010-02-10 16:18:26 -05006274 temp_fea = (struct fea *)temp_ptr;
6275 }
6276
Jeff Layton31c05192010-02-10 16:18:26 -05006277 /* didn't find the named attribute */
6278 if (ea_name)
6279 rc = -ENODATA;
6280
Jeff Laytonf0d38682010-02-10 16:18:26 -05006281QAllEAsOut:
Steve French0d817bc2008-05-22 02:02:03 +00006282 cifs_buf_release(pSMB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006283 if (rc == -EAGAIN)
6284 goto QAllEAsRetry;
6285
6286 return (ssize_t)rc;
6287}
6288
Linus Torvalds1da177e2005-04-16 15:20:36 -07006289int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04006290CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
6291 const char *fileName, const char *ea_name, const void *ea_value,
Steve French50c2f752007-07-13 00:33:32 +00006292 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6293 int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006294{
6295 struct smb_com_transaction2_spi_req *pSMB = NULL;
6296 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6297 struct fealist *parm_data;
6298 int name_len;
6299 int rc = 0;
6300 int bytes_returned = 0;
6301 __u16 params, param_offset, byte_count, offset, count;
6302
Joe Perchesf96637b2013-05-04 22:12:25 -05006303 cifs_dbg(FYI, "In SetEA\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07006304SetEARetry:
6305 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6306 (void **) &pSMBr);
6307 if (rc)
6308 return rc;
6309
6310 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6311 name_len =
Steve Frenchacbbb762012-01-18 22:32:33 -06006312 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6313 PATH_MAX, nls_codepage, remap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006314 name_len++; /* trailing null */
6315 name_len *= 2;
Steve French50c2f752007-07-13 00:33:32 +00006316 } else { /* BB improve the check for buffer overruns BB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07006317 name_len = strnlen(fileName, PATH_MAX);
6318 name_len++; /* trailing null */
6319 strncpy(pSMB->FileName, fileName, name_len);
6320 }
6321
6322 params = 6 + name_len;
6323
6324 /* done calculating parms using name_len of file name,
6325 now use name_len to calculate length of ea name
6326 we are going to create in the inode xattrs */
Steve French790fe572007-07-07 19:25:05 +00006327 if (ea_name == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006328 name_len = 0;
6329 else
Steve French50c2f752007-07-13 00:33:32 +00006330 name_len = strnlen(ea_name, 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006331
Steve Frenchdae5dbdb2007-12-30 23:49:57 +00006332 count = sizeof(*parm_data) + ea_value_len + name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006333 pSMB->MaxParameterCount = cpu_to_le16(2);
Steve French582d21e2008-05-13 04:54:12 +00006334 /* BB find max SMB PDU from sess */
6335 pSMB->MaxDataCount = cpu_to_le16(1000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006336 pSMB->MaxSetupCount = 0;
6337 pSMB->Reserved = 0;
6338 pSMB->Flags = 0;
6339 pSMB->Timeout = 0;
6340 pSMB->Reserved2 = 0;
6341 param_offset = offsetof(struct smb_com_transaction2_spi_req,
Steve French50c2f752007-07-13 00:33:32 +00006342 InformationLevel) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006343 offset = param_offset + params;
6344 pSMB->InformationLevel =
6345 cpu_to_le16(SMB_SET_FILE_EA);
6346
6347 parm_data =
6348 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6349 offset);
6350 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6351 pSMB->DataOffset = cpu_to_le16(offset);
6352 pSMB->SetupCount = 1;
6353 pSMB->Reserved3 = 0;
6354 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6355 byte_count = 3 /* pad */ + params + count;
6356 pSMB->DataCount = cpu_to_le16(count);
6357 parm_data->list_len = cpu_to_le32(count);
6358 parm_data->list[0].EA_flags = 0;
6359 /* we checked above that name len is less than 255 */
Alexey Dobriyan53b35312006-03-24 03:16:13 -08006360 parm_data->list[0].name_len = (__u8)name_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07006361 /* EA names are always ASCII */
Steve French790fe572007-07-07 19:25:05 +00006362 if (ea_name)
Steve French50c2f752007-07-13 00:33:32 +00006363 strncpy(parm_data->list[0].name, ea_name, name_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006364 parm_data->list[0].name[name_len] = 0;
6365 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6366 /* caller ensures that ea_value_len is less than 64K but
6367 we need to ensure that it fits within the smb */
6368
Steve French50c2f752007-07-13 00:33:32 +00006369 /*BB add length check to see if it would fit in
6370 negotiated SMB buffer size BB */
Steve French790fe572007-07-07 19:25:05 +00006371 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6372 if (ea_value_len)
Steve French50c2f752007-07-13 00:33:32 +00006373 memcpy(parm_data->list[0].name+name_len+1,
6374 ea_value, ea_value_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006375
6376 pSMB->TotalDataCount = pSMB->DataCount;
6377 pSMB->ParameterCount = cpu_to_le16(params);
6378 pSMB->TotalParameterCount = pSMB->ParameterCount;
6379 pSMB->Reserved4 = 0;
Steve Frenchbe8e3b02011-04-29 05:40:20 +00006380 inc_rfc1001_len(pSMB, byte_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006381 pSMB->ByteCount = cpu_to_le16(byte_count);
6382 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6383 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
Steve Frenchad7a2922008-02-07 23:25:02 +00006384 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05006385 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07006386
6387 cifs_buf_release(pSMB);
6388
6389 if (rc == -EAGAIN)
6390 goto SetEARetry;
6391
6392 return rc;
6393}
Linus Torvalds1da177e2005-04-16 15:20:36 -07006394#endif
Steve French0eff0e22011-02-24 05:39:23 +00006395
6396#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6397/*
6398 * Years ago the kernel added a "dnotify" function for Samba server,
6399 * to allow network clients (such as Windows) to display updated
6400 * lists of files in directory listings automatically when
6401 * files are added by one user when another user has the
6402 * same directory open on their desktop. The Linux cifs kernel
6403 * client hooked into the kernel side of this interface for
6404 * the same reason, but ironically when the VFS moved from
6405 * "dnotify" to "inotify" it became harder to plug in Linux
6406 * network file system clients (the most obvious use case
6407 * for notify interfaces is when multiple users can update
6408 * the contents of the same directory - exactly what network
6409 * file systems can do) although the server (Samba) could
6410 * still use it. For the short term we leave the worker
6411 * function ifdeffed out (below) until inotify is fixed
6412 * in the VFS to make it easier to plug in network file
6413 * system clients. If inotify turns out to be permanently
6414 * incompatible for network fs clients, we could instead simply
6415 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6416 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04006417int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
Steve French0eff0e22011-02-24 05:39:23 +00006418 const int notify_subdirs, const __u16 netfid,
6419 __u32 filter, struct file *pfile, int multishot,
6420 const struct nls_table *nls_codepage)
6421{
6422 int rc = 0;
6423 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6424 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6425 struct dir_notify_req *dnotify_req;
6426 int bytes_returned;
6427
Joe Perchesf96637b2013-05-04 22:12:25 -05006428 cifs_dbg(FYI, "In CIFSSMBNotify for file handle %d\n", (int)netfid);
Steve French0eff0e22011-02-24 05:39:23 +00006429 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6430 (void **) &pSMBr);
6431 if (rc)
6432 return rc;
6433
6434 pSMB->TotalParameterCount = 0 ;
6435 pSMB->TotalDataCount = 0;
6436 pSMB->MaxParameterCount = cpu_to_le32(2);
Jeff Laytonc974bef2011-10-11 06:41:32 -04006437 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
Steve French0eff0e22011-02-24 05:39:23 +00006438 pSMB->MaxSetupCount = 4;
6439 pSMB->Reserved = 0;
6440 pSMB->ParameterOffset = 0;
6441 pSMB->DataCount = 0;
6442 pSMB->DataOffset = 0;
6443 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6444 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6445 pSMB->ParameterCount = pSMB->TotalParameterCount;
6446 if (notify_subdirs)
6447 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6448 pSMB->Reserved2 = 0;
6449 pSMB->CompletionFilter = cpu_to_le32(filter);
6450 pSMB->Fid = netfid; /* file handle always le */
6451 pSMB->ByteCount = 0;
6452
6453 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6454 (struct smb_hdr *)pSMBr, &bytes_returned,
6455 CIFS_ASYNC_OP);
6456 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05006457 cifs_dbg(FYI, "Error in Notify = %d\n", rc);
Steve French0eff0e22011-02-24 05:39:23 +00006458 } else {
6459 /* Add file to outstanding requests */
6460 /* BB change to kmem cache alloc */
6461 dnotify_req = kmalloc(
6462 sizeof(struct dir_notify_req),
6463 GFP_KERNEL);
6464 if (dnotify_req) {
6465 dnotify_req->Pid = pSMB->hdr.Pid;
6466 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6467 dnotify_req->Mid = pSMB->hdr.Mid;
6468 dnotify_req->Tid = pSMB->hdr.Tid;
6469 dnotify_req->Uid = pSMB->hdr.Uid;
6470 dnotify_req->netfid = netfid;
6471 dnotify_req->pfile = pfile;
6472 dnotify_req->filter = filter;
6473 dnotify_req->multishot = multishot;
6474 spin_lock(&GlobalMid_Lock);
6475 list_add_tail(&dnotify_req->lhead,
6476 &GlobalDnotifyReqList);
6477 spin_unlock(&GlobalMid_Lock);
6478 } else
6479 rc = -ENOMEM;
6480 }
6481 cifs_buf_release(pSMB);
6482 return rc;
6483}
6484#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */