projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cifs: abstract out function to marshal up the iovec array for async writes
[deliverable/linux.git] / fs / cifs / cifssmb.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/cifssmb.c
3 *
f19159dc 4 * Copyright (C) International Business Machines Corp., 2002,2010
1da177e4
LT		 5 * 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 */
2dd29d31
SF		 27 /* 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 */
1da177e4
LT		 29
30#include <linux/fs.h>
31#include <linux/kernel.h>
32#include <linux/vfs.h>
5a0e3ad6 33#include <linux/slab.h>
1da177e4 34#include <linux/posix_acl_xattr.h>
c28c89fc 35#include <linux/pagemap.h>
e28bc5b1
JL		 36#include <linux/swap.h>
37#include <linux/task_io_accounting_ops.h>
1da177e4
LT		 38#include <asm/uaccess.h>
39#include "cifspdu.h"
40#include "cifsglob.h"
d0d66c44 41#include "cifsacl.h"
1da177e4
LT		 42#include "cifsproto.h"
43#include "cifs_unicode.h"
44#include "cifs_debug.h"
e28bc5b1 45#include "fscache.h"
1da177e4
LT		 46
47#ifdef CONFIG_CIFS_POSIX
48static struct {
49 int index;
50 char *name;
51} protocols[] = {
3979877e
SF		 52#ifdef CONFIG_CIFS_WEAK_PW_HASH
53 {LANMAN_PROT, "\2LM1.2X002"},
9ac00b7d 54 {LANMAN2_PROT, "\2LANMAN2.1"},
3979877e 55#endif /* weak password hashing for legacy clients */
50c2f753 56 {CIFS_PROT, "\2NT LM 0.12"},
3979877e 57 {POSIX_PROT, "\2POSIX 2"},
1da177e4
LT		 58 {BAD_PROT, "\2"}
59};
60#else
61static struct {
62 int index;
63 char *name;
64} protocols[] = {
3979877e
SF		 65#ifdef CONFIG_CIFS_WEAK_PW_HASH
66 {LANMAN_PROT, "\2LM1.2X002"},
18f75ca0 67 {LANMAN2_PROT, "\2LANMAN2.1"},
3979877e 68#endif /* weak password hashing for legacy clients */
790fe579 69 {CIFS_PROT, "\2NT LM 0.12"},
1da177e4
LT		 70 {BAD_PROT, "\2"}
71};
72#endif
73
3979877e
SF		 74/* define the number of elements in the cifs dialect array */
75#ifdef CONFIG_CIFS_POSIX
76#ifdef CONFIG_CIFS_WEAK_PW_HASH
9ac00b7d 77#define CIFS_NUM_PROT 4
3979877e
SF		 78#else
79#define CIFS_NUM_PROT 2
80#endif /* CIFS_WEAK_PW_HASH */
81#else /* not posix */
82#ifdef CONFIG_CIFS_WEAK_PW_HASH
9ac00b7d 83#define CIFS_NUM_PROT 3
3979877e
SF		 84#else
85#define CIFS_NUM_PROT 1
86#endif /* CONFIG_CIFS_WEAK_PW_HASH */
87#endif /* CIFS_POSIX */
88
e28bc5b1
JL		 89/* Forward declarations */
90static void cifs_readv_complete(struct work_struct *work);
91
1da177e4
LT		 92/* Mark as invalid, all open files on tree connections since they
93 were closed when session to server was lost */
96daf2b0 94static void mark_open_files_invalid(struct cifs_tcon *pTcon)
1da177e4
LT		 95{
96 struct cifsFileInfo *open_file = NULL;
790fe579
SF		 97 struct list_head *tmp;
98 struct list_head *tmp1;
1da177e4
LT		 99
100/* list all files open on tree connection and mark them invalid */
4477288a 101 spin_lock(&cifs_file_list_lock);
1da177e4 102 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
790fe579 103 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
ad8b15f0 104 open_file->invalidHandle = true;
3bc303c2 105 open_file->oplock_break_cancelled = true;
1da177e4 106 }
4477288a 107 spin_unlock(&cifs_file_list_lock);
09d1db5c
SF		 108 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
109 to this tcon */
1da177e4
LT		 110}
111
9162ab20
JL		 112/* reconnect the socket, tcon, and smb session if needed */
113static int
96daf2b0 114cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
9162ab20 115{
c4a5534a 116 int rc;
96daf2b0 117 struct cifs_ses *ses;
9162ab20
JL		 118 struct TCP_Server_Info *server;
119 struct nls_table *nls_codepage;
120
121 /*
122 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
123 * tcp and smb session status done differently for those three - in the
124 * calling routine
125 */
126 if (!tcon)
127 return 0;
128
129 ses = tcon->ses;
130 server = ses->server;
131
132 /*
133 * only tree disconnect, open, and write, (and ulogoff which does not
134 * have tcon) are allowed as we start force umount
135 */
136 if (tcon->tidStatus == CifsExiting) {
137 if (smb_command != SMB_COM_WRITE_ANDX &&
138 smb_command != SMB_COM_OPEN_ANDX &&
139 smb_command != SMB_COM_TREE_DISCONNECT) {
b6b38f70
JP		 140 cFYI(1, "can not send cmd %d while umounting",
141 smb_command);
9162ab20
JL		 142 return -ENODEV;
143 }
144 }
145
9162ab20
JL		 146 /*
147 * Give demultiplex thread up to 10 seconds to reconnect, should be
148 * greater than cifs socket timeout which is 7 seconds
149 */
150 while (server->tcpStatus == CifsNeedReconnect) {
151 wait_event_interruptible_timeout(server->response_q,
fd88ce93 152 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
9162ab20 153
fd88ce93 154 /* are we still trying to reconnect? */
9162ab20
JL		 155 if (server->tcpStatus != CifsNeedReconnect)
156 break;
157
158 /*
159 * on "soft" mounts we wait once. Hard mounts keep
160 * retrying until process is killed or server comes
161 * back on-line
162 */
d402539b 163 if (!tcon->retry) {
b6b38f70 164 cFYI(1, "gave up waiting on reconnect in smb_init");
9162ab20
JL		 165 return -EHOSTDOWN;
166 }
167 }
168
169 if (!ses->need_reconnect && !tcon->need_reconnect)
170 return 0;
171
172 nls_codepage = load_nls_default();
173
174 /*
175 * need to prevent multiple threads trying to simultaneously
176 * reconnect the same SMB session
177 */
d7b619cf 178 mutex_lock(&ses->session_mutex);
198b5682
JL		 179 rc = cifs_negotiate_protocol(0, ses);
180 if (rc == 0 && ses->need_reconnect)
9162ab20
JL		 181 rc = cifs_setup_session(0, ses, nls_codepage);
182
183 /* do we need to reconnect tcon? */
184 if (rc || !tcon->need_reconnect) {
d7b619cf 185 mutex_unlock(&ses->session_mutex);
9162ab20
JL		 186 goto out;
187 }
188
189 mark_open_files_invalid(tcon);
190 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
d7b619cf 191 mutex_unlock(&ses->session_mutex);
b6b38f70 192 cFYI(1, "reconnect tcon rc = %d", rc);
9162ab20
JL		 193
194 if (rc)
195 goto out;
196
197 /*
198 * FIXME: check if wsize needs updated due to negotiated smb buffer
199 * size shrinking
200 */
201 atomic_inc(&tconInfoReconnectCount);
202
203 /* tell server Unix caps we support */
204 if (ses->capabilities & CAP_UNIX)
205 reset_cifs_unix_caps(0, tcon, NULL, NULL);
206
207 /*
208 * Removed call to reopen open files here. It is safer (and faster) to
209 * reopen files one at a time as needed in read and write.
210 *
211 * FIXME: what about file locks? don't we need to reclaim them ASAP?
212 */
213
214out:
215 /*
216 * Check if handle based operation so we know whether we can continue
217 * or not without returning to caller to reset file handle
218 */
219 switch (smb_command) {
220 case SMB_COM_READ_ANDX:
221 case SMB_COM_WRITE_ANDX:
222 case SMB_COM_CLOSE:
223 case SMB_COM_FIND_CLOSE2:
224 case SMB_COM_LOCKING_ANDX:
225 rc = -EAGAIN;
226 }
227
228 unload_nls(nls_codepage);
229 return rc;
230}
231
ad7a2926
SF		 232/* Allocate and return pointer to an SMB request buffer, and set basic
233 SMB information in the SMB header. If the return code is zero, this
234 function must have filled in request_buf pointer */
1da177e4 235static int
96daf2b0 236small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
ad7a2926 237 void **request_buf)
1da177e4 238{
f569599a 239 int rc;
1da177e4 240
9162ab20 241 rc = cifs_reconnect_tcon(tcon, smb_command);
790fe579 242 if (rc)
1da177e4
LT		 243 return rc;
244
245 *request_buf = cifs_small_buf_get();
246 if (*request_buf == NULL) {
247 /* BB should we add a retry in here if not a writepage? */
248 return -ENOMEM;
249 }
250
63135e08 251 header_assemble((struct smb_hdr *) *request_buf, smb_command,
c18c842b 252 tcon, wct);
1da177e4 253
790fe579
SF		 254 if (tcon != NULL)
255 cifs_stats_inc(&tcon->num_smbs_sent);
a4544347 256
f569599a 257 return 0;
5815449d
SF		 258}
259
12b3b8ff 260int
50c2f753 261small_smb_init_no_tc(const int smb_command, const int wct,
96daf2b0 262 struct cifs_ses *ses, void **request_buf)
12b3b8ff
SF		 263{
264 int rc;
50c2f753 265 struct smb_hdr *buffer;
12b3b8ff 266
5815449d 267 rc = small_smb_init(smb_command, wct, NULL, request_buf);
790fe579 268 if (rc)
12b3b8ff
SF		 269 return rc;
270
04fdabe1 271 buffer = (struct smb_hdr *)*request_buf;
12b3b8ff
SF		 272 buffer->Mid = GetNextMid(ses->server);
273 if (ses->capabilities & CAP_UNICODE)
274 buffer->Flags2 |= SMBFLG2_UNICODE;
04fdabe1 275 if (ses->capabilities & CAP_STATUS32)
12b3b8ff
SF		 276 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
277
278 /* uid, tid can stay at zero as set in header assemble */
279
50c2f753 280 /* BB add support for turning on the signing when
12b3b8ff
SF		 281 this function is used after 1st of session setup requests */
282
283 return rc;
284}
1da177e4
LT		 285
286/* If the return code is zero, this function must fill in request_buf pointer */
287static int
96daf2b0 288__smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
f569599a 289 void **request_buf, void **response_buf)
1da177e4 290{
1da177e4
LT		 291 *request_buf = cifs_buf_get();
292 if (*request_buf == NULL) {
293 /* BB should we add a retry in here if not a writepage? */
294 return -ENOMEM;
295 }
296 /* Although the original thought was we needed the response buf for */
297 /* potential retries of smb operations it turns out we can determine */
298 /* from the mid flags when the request buffer can be resent without */
299 /* having to use a second distinct buffer for the response */
790fe579 300 if (response_buf)
50c2f753 301 *response_buf = *request_buf;
1da177e4
LT		 302
303 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
ad7a2926 304 wct);
1da177e4 305
790fe579
SF		 306 if (tcon != NULL)
307 cifs_stats_inc(&tcon->num_smbs_sent);
a4544347 308
f569599a
JL		 309 return 0;
310}
311
312/* If the return code is zero, this function must fill in request_buf pointer */
313static int
96daf2b0 314smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
f569599a
JL		 315 void **request_buf, void **response_buf)
316{
317 int rc;
318
319 rc = cifs_reconnect_tcon(tcon, smb_command);
320 if (rc)
321 return rc;
322
323 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
324}
325
326static int
96daf2b0 327smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
f569599a
JL		 328 void **request_buf, void **response_buf)
329{
330 if (tcon->ses->need_reconnect || tcon->need_reconnect)
331 return -EHOSTDOWN;
332
333 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
1da177e4
LT		 334}
335
50c2f753 336static int validate_t2(struct smb_t2_rsp *pSMB)
1da177e4 337{
12df83c9
JL		 338 unsigned int total_size;
339
340 /* check for plausible wct */
341 if (pSMB->hdr.WordCount < 10)
342 goto vt2_err;
1da177e4 343
1da177e4 344 /* check for parm and data offset going beyond end of smb */
12df83c9
JL		 345 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
346 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
347 goto vt2_err;
348
12df83c9
JL		 349 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
350 if (total_size >= 512)
351 goto vt2_err;
352
fd5707e1
JL		 353 /* check that bcc is at least as big as parms + data, and that it is
354 * less than negotiated smb buffer
355 */
12df83c9
JL		 356 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
357 if (total_size > get_bcc(&pSMB->hdr) ||
358 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
359 goto vt2_err;
360
361 return 0;
362vt2_err:
50c2f753 363 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
1da177e4 364 sizeof(struct smb_t2_rsp) + 16);
12df83c9 365 return -EINVAL;
1da177e4 366}
690c522f 367
be8e3b00
SF		 368static inline void inc_rfc1001_len(void *pSMB, int count)
369{
370 struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
371
372 be32_add_cpu(&hdr->smb_buf_length, count);
373}
374
1da177e4 375int
96daf2b0 376CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses)
1da177e4
LT		 377{
378 NEGOTIATE_REQ *pSMB;
379 NEGOTIATE_RSP *pSMBr;
380 int rc = 0;
381 int bytes_returned;
3979877e 382 int i;
50c2f753 383 struct TCP_Server_Info *server;
1da177e4 384 u16 count;
750d1151 385 unsigned int secFlags;
1da177e4 386
790fe579 387 if (ses->server)
1da177e4
LT		 388 server = ses->server;
389 else {
390 rc = -EIO;
391 return rc;
392 }
393 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
394 (void **) &pSMB, (void **) &pSMBr);
395 if (rc)
396 return rc;
750d1151
SF		 397
398 /* if any of auth flags (ie not sign or seal) are overriden use them */
790fe579 399 if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
762e5ab7 400 secFlags = ses->overrideSecFlg; /* BB FIXME fix sign flags? */
750d1151 401 else /* if override flags set only sign/seal OR them with global auth */
04912d6a 402 secFlags = global_secflags | ses->overrideSecFlg;
750d1151 403
b6b38f70 404 cFYI(1, "secFlags 0x%x", secFlags);
f40c5628 405
1982c344 406 pSMB->hdr.Mid = GetNextMid(server);
100c1ddc 407 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
a013689d 408
100c1ddc 409 if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
254e55ed 410 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
a013689d 411 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
b6b38f70 412 cFYI(1, "Kerberos only mechanism, enable extended security");
a013689d 413 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
b4d6fcf1 414 } else if ((secFlags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
ac683924
SF		 415 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
416 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_NTLMSSP) {
b6b38f70 417 cFYI(1, "NTLMSSP only mechanism, enable extended security");
ac683924
SF		 418 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
419 }
50c2f753 420
3979877e 421 count = 0;
50c2f753 422 for (i = 0; i < CIFS_NUM_PROT; i++) {
3979877e
SF		 423 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
424 count += strlen(protocols[i].name) + 1;
425 /* null at end of source and target buffers anyway */
426 }
be8e3b00 427 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 428 pSMB->ByteCount = cpu_to_le16(count);
429
430 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
431 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
50c2f753 432 if (rc != 0)
254e55ed
SF		 433 goto neg_err_exit;
434
9bf67e51
JL		 435 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
436 cFYI(1, "Dialect: %d", server->dialect);
254e55ed 437 /* Check wct = 1 error case */
9bf67e51 438 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
254e55ed 439 /* core returns wct = 1, but we do not ask for core - otherwise
50c2f753 440 small wct just comes when dialect index is -1 indicating we
254e55ed
SF		 441 could not negotiate a common dialect */
442 rc = -EOPNOTSUPP;
443 goto neg_err_exit;
50c2f753 444#ifdef CONFIG_CIFS_WEAK_PW_HASH
790fe579 445 } else if ((pSMBr->hdr.WordCount == 13)
9bf67e51
JL		 446 && ((server->dialect == LANMAN_PROT)
447 || (server->dialect == LANMAN2_PROT))) {
b815f1e5 448 __s16 tmp;
50c2f753 449 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
254e55ed 450
790fe579 451 if ((secFlags & CIFSSEC_MAY_LANMAN) ||
750d1151 452 (secFlags & CIFSSEC_MAY_PLNTXT))
254e55ed
SF		 453 server->secType = LANMAN;
454 else {
b6b38f70
JP		 455 cERROR(1, "mount failed weak security disabled"
456 " in /proc/fs/cifs/SecurityFlags");
3979877e
SF		 457 rc = -EOPNOTSUPP;
458 goto neg_err_exit;
50c2f753 459 }
96daf2b0 460 server->sec_mode = (__u8)le16_to_cpu(rsp->SecurityMode);
10b9b98e
PS		 461 server->maxReq = min_t(unsigned int,
462 le16_to_cpu(rsp->MaxMpxCount),
463 cifs_max_pending);
2d86dbc9 464 cifs_set_credits(server, server->maxReq);
c974befa 465 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
eca6acf9 466 server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
254e55ed
SF		 467 /* even though we do not use raw we might as well set this
468 accurately, in case we ever find a need for it */
790fe579 469 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
eca6acf9 470 server->max_rw = 0xFF00;
254e55ed
SF		 471 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
472 } else {
eca6acf9 473 server->max_rw = 0;/* do not need to use raw anyway */
254e55ed
SF		 474 server->capabilities = CAP_MPX_MODE;
475 }
b815f1e5 476 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
1a70d652 477 if (tmp == -1) {
25ee4a98
SF		 478 /* OS/2 often does not set timezone therefore
479 * we must use server time to calc time zone.
b815f1e5
SF		 480 * Could deviate slightly from the right zone.
481 * Smallest defined timezone difference is 15 minutes
482 * (i.e. Nepal). Rounding up/down is done to match
483 * this requirement.
25ee4a98 484 */
b815f1e5 485 int val, seconds, remain, result;
25ee4a98
SF		 486 struct timespec ts, utc;
487 utc = CURRENT_TIME;
c4a2c08d
JL		 488 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
489 rsp->SrvTime.Time, 0);
b6b38f70 490 cFYI(1, "SrvTime %d sec since 1970 (utc: %d) diff: %d",
50c2f753 491 (int)ts.tv_sec, (int)utc.tv_sec,
b6b38f70 492 (int)(utc.tv_sec - ts.tv_sec));
b815f1e5 493 val = (int)(utc.tv_sec - ts.tv_sec);
8594c15a 494 seconds = abs(val);
947a5067 495 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
b815f1e5 496 remain = seconds % MIN_TZ_ADJ;
790fe579 497 if (remain >= (MIN_TZ_ADJ / 2))
b815f1e5 498 result += MIN_TZ_ADJ;
790fe579 499 if (val < 0)
ad7a2926 500 result = -result;
b815f1e5 501 server->timeAdj = result;
25ee4a98 502 } else {
b815f1e5
SF		 503 server->timeAdj = (int)tmp;
504 server->timeAdj *= 60; /* also in seconds */
25ee4a98 505 }
b6b38f70 506 cFYI(1, "server->timeAdj: %d seconds", server->timeAdj);
25ee4a98 507
3979877e 508
254e55ed 509 /* BB get server time for time conversions and add
50c2f753 510 code to use it and timezone since this is not UTC */
3979877e 511
50c2f753 512 if (rsp->EncryptionKeyLength ==
25ee4a98 513 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
d3ba50b1 514 memcpy(ses->server->cryptkey, rsp->EncryptionKey,
254e55ed 515 CIFS_CRYPTO_KEY_SIZE);
96daf2b0 516 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
254e55ed
SF		 517 rc = -EIO; /* need cryptkey unless plain text */
518 goto neg_err_exit;
519 }
3979877e 520
f19159dc 521 cFYI(1, "LANMAN negotiated");
254e55ed
SF		 522 /* we will not end up setting signing flags - as no signing
523 was in LANMAN and server did not return the flags on */
524 goto signing_check;
7c7b25bc 525#else /* weak security disabled */
790fe579 526 } else if (pSMBr->hdr.WordCount == 13) {
f19159dc
SF		 527 cERROR(1, "mount failed, cifs module not built "
528 "with CIFS_WEAK_PW_HASH support");
8212cf75 529 rc = -EOPNOTSUPP;
7c7b25bc 530#endif /* WEAK_PW_HASH */
254e55ed 531 goto neg_err_exit;
790fe579 532 } else if (pSMBr->hdr.WordCount != 17) {
254e55ed
SF		 533 /* unknown wct */
534 rc = -EOPNOTSUPP;
535 goto neg_err_exit;
536 }
537 /* else wct == 17 NTLM */
96daf2b0
SF		 538 server->sec_mode = pSMBr->SecurityMode;
539 if ((server->sec_mode & SECMODE_USER) == 0)
b6b38f70 540 cFYI(1, "share mode security");
bdc4bf6e 541
96daf2b0 542 if ((server->sec_mode & SECMODE_PW_ENCRYPT) == 0)
bdc4bf6e 543#ifdef CONFIG_CIFS_WEAK_PW_HASH
750d1151 544 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
bdc4bf6e 545#endif /* CIFS_WEAK_PW_HASH */
b6b38f70
JP		 546 cERROR(1, "Server requests plain text password"
547 " but client support disabled");
9312f675 548
790fe579 549 if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
254e55ed 550 server->secType = NTLMv2;
790fe579 551 else if (secFlags & CIFSSEC_MAY_NTLM)
254e55ed 552 server->secType = NTLM;
790fe579 553 else if (secFlags & CIFSSEC_MAY_NTLMV2)
f40c5628 554 server->secType = NTLMv2;
a013689d
SF		 555 else if (secFlags & CIFSSEC_MAY_KRB5)
556 server->secType = Kerberos;
ac683924 557 else if (secFlags & CIFSSEC_MAY_NTLMSSP)
f46c7234 558 server->secType = RawNTLMSSP;
a013689d
SF		 559 else if (secFlags & CIFSSEC_MAY_LANMAN)
560 server->secType = LANMAN;
a013689d
SF		 561 else {
562 rc = -EOPNOTSUPP;
b6b38f70 563 cERROR(1, "Invalid security type");
a013689d
SF		 564 goto neg_err_exit;
565 }
566 /* else ... any others ...? */
254e55ed
SF		 567
568 /* one byte, so no need to convert this or EncryptionKeyLen from
569 little endian */
10b9b98e
PS		 570 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
571 cifs_max_pending);
2d86dbc9 572 cifs_set_credits(server, server->maxReq);
254e55ed 573 /* probably no need to store and check maxvcs */
c974befa 574 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
eca6acf9 575 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
b6b38f70 576 cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
254e55ed 577 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
b815f1e5
SF		 578 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
579 server->timeAdj *= 60;
254e55ed 580 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
d3ba50b1 581 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
254e55ed 582 CIFS_CRYPTO_KEY_SIZE);
07cc6cf9
SF		 583 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
584 server->capabilities & CAP_EXTENDED_SECURITY) &&
585 (pSMBr->EncryptionKeyLength == 0)) {
254e55ed 586 /* decode security blob */
820a803f 587 count = get_bcc(&pSMBr->hdr);
e187e44e 588 if (count < 16) {
254e55ed 589 rc = -EIO;
e187e44e
JL		 590 goto neg_err_exit;
591 }
3f9bcca7 592 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 593 if (server->srv_count > 1) {
3f9bcca7 594 spin_unlock(&cifs_tcp_ses_lock);
e187e44e
JL		 595 if (memcmp(server->server_GUID,
596 pSMBr->u.extended_response.
597 GUID, 16) != 0) {
b6b38f70 598 cFYI(1, "server UID changed");
254e55ed 599 memcpy(server->server_GUID,
e187e44e
JL		 600 pSMBr->u.extended_response.GUID,
601 16);
602 }
e7ddee90 603 } else {
3f9bcca7 604 spin_unlock(&cifs_tcp_ses_lock);
e187e44e
JL		 605 memcpy(server->server_GUID,
606 pSMBr->u.extended_response.GUID, 16);
e7ddee90 607 }
e187e44e
JL		 608
609 if (count == 16) {
610 server->secType = RawNTLMSSP;
254e55ed
SF		 611 } else {
612 rc = decode_negTokenInit(pSMBr->u.extended_response.
26efa0ba
JL		 613 SecurityBlob, count - 16,
614 server);
ef571cad 615 if (rc == 1)
e545937a 616 rc = 0;
ef571cad 617 else
254e55ed 618 rc = -EINVAL;
2b149f11
SP		 619 if (server->secType == Kerberos) {
620 if (!server->sec_kerberos &&
621 !server->sec_mskerberos)
622 rc = -EOPNOTSUPP;
623 } else if (server->secType == RawNTLMSSP) {
624 if (!server->sec_ntlmssp)
625 rc = -EOPNOTSUPP;
626 } else
627 rc = -EOPNOTSUPP;
1da177e4 628 }
96daf2b0 629 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
07cc6cf9
SF		 630 rc = -EIO; /* no crypt key only if plain text pwd */
631 goto neg_err_exit;
254e55ed
SF		 632 } else
633 server->capabilities &= ~CAP_EXTENDED_SECURITY;
634
6344a423 635#ifdef CONFIG_CIFS_WEAK_PW_HASH
254e55ed 636signing_check:
6344a423 637#endif
762e5ab7
SF		 638 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
639 /* MUST_SIGN already includes the MAY_SIGN FLAG
640 so if this is zero it means that signing is disabled */
b6b38f70 641 cFYI(1, "Signing disabled");
96daf2b0 642 if (server->sec_mode & SECMODE_SIGN_REQUIRED) {
b6b38f70 643 cERROR(1, "Server requires "
7111d214 644 "packet signing to be enabled in "
b6b38f70 645 "/proc/fs/cifs/SecurityFlags.");
abb63d6c
SF		 646 rc = -EOPNOTSUPP;
647 }
96daf2b0 648 server->sec_mode &=
254e55ed 649 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
762e5ab7
SF		 650 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
651 /* signing required */
b6b38f70 652 cFYI(1, "Must sign - secFlags 0x%x", secFlags);
96daf2b0 653 if ((server->sec_mode &
762e5ab7 654 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
b6b38f70 655 cERROR(1, "signing required but server lacks support");
38c10a1d 656 rc = -EOPNOTSUPP;
762e5ab7 657 } else
96daf2b0 658 server->sec_mode |= SECMODE_SIGN_REQUIRED;
762e5ab7
SF		 659 } else {
660 /* signing optional ie CIFSSEC_MAY_SIGN */
96daf2b0
SF		 661 if ((server->sec_mode & SECMODE_SIGN_REQUIRED) == 0)
662 server->sec_mode &=
254e55ed 663 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
1da177e4 664 }
50c2f753
SF		 665
666neg_err_exit:
4a6d87f1 667 cifs_buf_release(pSMB);
254e55ed 668
b6b38f70 669 cFYI(1, "negprot rc %d", rc);
1da177e4
LT		 670 return rc;
671}
672
673int
96daf2b0 674CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
1da177e4
LT		 675{
676 struct smb_hdr *smb_buffer;
1da177e4 677 int rc = 0;
1da177e4 678
b6b38f70 679 cFYI(1, "In tree disconnect");
1da177e4 680
f1987b44
JL		 681 /* BB: do we need to check this? These should never be NULL. */
682 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
683 return -EIO;
1da177e4 684
f1987b44
JL		 685 /*
686 * No need to return error on this operation if tid invalidated and
687 * closed on server already e.g. due to tcp session crashing. Also,
688 * the tcon is no longer on the list, so no need to take lock before
689 * checking this.
690 */
268875b9 691 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
50c2f753 692 return 0;
1da177e4 693
50c2f753 694 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
09d1db5c 695 (void **)&smb_buffer);
f1987b44 696 if (rc)
1da177e4 697 return rc;
133672ef 698
792af7b0 699 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
1da177e4 700 if (rc)
b6b38f70 701 cFYI(1, "Tree disconnect failed %d", rc);
1da177e4 702
50c2f753 703 /* No need to return error on this operation if tid invalidated and
f1987b44 704 closed on server already e.g. due to tcp session crashing */
1da177e4
LT		 705 if (rc == -EAGAIN)
706 rc = 0;
707
708 return rc;
709}
710
766fdbb5
JL		 711/*
712 * This is a no-op for now. We're not really interested in the reply, but
713 * rather in the fact that the server sent one and that server->lstrp
714 * gets updated.
715 *
716 * FIXME: maybe we should consider checking that the reply matches request?
717 */
718static void
719cifs_echo_callback(struct mid_q_entry *mid)
720{
721 struct TCP_Server_Info *server = mid->callback_data;
722
723 DeleteMidQEntry(mid);
2d86dbc9 724 cifs_add_credits(server, 1);
766fdbb5
JL		 725}
726
727int
728CIFSSMBEcho(struct TCP_Server_Info *server)
729{
730 ECHO_REQ *smb;
731 int rc = 0;
fcc31cb6 732 struct kvec iov;
766fdbb5
JL		 733
734 cFYI(1, "In echo request");
735
736 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
737 if (rc)
738 return rc;
739
740 /* set up echo request */
5443d130 741 smb->hdr.Tid = 0xffff;
99d86c8f
JL		 742 smb->hdr.WordCount = 1;
743 put_unaligned_le16(1, &smb->EchoCount);
820a803f 744 put_bcc(1, &smb->hdr);
766fdbb5 745 smb->Data[0] = 'a';
be8e3b00 746 inc_rfc1001_len(smb, 3);
fcc31cb6
JL		 747 iov.iov_base = smb;
748 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
766fdbb5 749
44d22d84
JL		 750 rc = cifs_call_async(server, &iov, 1, NULL, cifs_echo_callback,
751 server, true);
766fdbb5
JL		 752 if (rc)
753 cFYI(1, "Echo request failed: %d", rc);
754
755 cifs_small_buf_release(smb);
756
757 return rc;
758}
759
1da177e4 760int
96daf2b0 761CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
1da177e4 762{
1da177e4
LT		 763 LOGOFF_ANDX_REQ *pSMB;
764 int rc = 0;
1da177e4 765
b6b38f70 766 cFYI(1, "In SMBLogoff for session disconnect");
3b795210 767
14fbf50d
JL		 768 /*
769 * BB: do we need to check validity of ses and server? They should
770 * always be valid since we have an active reference. If not, that
771 * should probably be a BUG()
772 */
773 if (!ses || !ses->server)
3b795210
SF		 774 return -EIO;
775
d7b619cf 776 mutex_lock(&ses->session_mutex);
3b795210
SF		 777 if (ses->need_reconnect)
778 goto session_already_dead; /* no need to send SMBlogoff if uid
779 already closed due to reconnect */
1da177e4
LT		 780 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
781 if (rc) {
d7b619cf 782 mutex_unlock(&ses->session_mutex);
1da177e4
LT		 783 return rc;
784 }
785
3b795210 786 pSMB->hdr.Mid = GetNextMid(ses->server);
1982c344 787
96daf2b0 788 if (ses->server->sec_mode &
1da177e4
LT		 789 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
790 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
1da177e4
LT		 791
792 pSMB->hdr.Uid = ses->Suid;
793
794 pSMB->AndXCommand = 0xFF;
792af7b0 795 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
3b795210 796session_already_dead:
d7b619cf 797 mutex_unlock(&ses->session_mutex);
1da177e4
LT		 798
799 /* if session dead then we do not need to do ulogoff,
50c2f753 800 since server closed smb session, no sense reporting
1da177e4
LT		 801 error */
802 if (rc == -EAGAIN)
803 rc = 0;
804 return rc;
805}
806
2d785a50 807int
96daf2b0 808CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
2d785a50
SF		 809 __u16 type, const struct nls_table *nls_codepage, int remap)
810{
811 TRANSACTION2_SPI_REQ *pSMB = NULL;
812 TRANSACTION2_SPI_RSP *pSMBr = NULL;
813 struct unlink_psx_rq *pRqD;
814 int name_len;
815 int rc = 0;
816 int bytes_returned = 0;
817 __u16 params, param_offset, offset, byte_count;
818
b6b38f70 819 cFYI(1, "In POSIX delete");
2d785a50
SF		 820PsxDelete:
821 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
822 (void **) &pSMBr);
823 if (rc)
824 return rc;
825
826 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
827 name_len =
acbbb76a
SF		 828 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
829 PATH_MAX, nls_codepage, remap);
2d785a50
SF		 830 name_len++; /* trailing null */
831 name_len *= 2;
832 } else { /* BB add path length overrun check */
833 name_len = strnlen(fileName, PATH_MAX);
834 name_len++; /* trailing null */
835 strncpy(pSMB->FileName, fileName, name_len);
836 }
837
838 params = 6 + name_len;
839 pSMB->MaxParameterCount = cpu_to_le16(2);
840 pSMB->MaxDataCount = 0; /* BB double check this with jra */
841 pSMB->MaxSetupCount = 0;
842 pSMB->Reserved = 0;
843 pSMB->Flags = 0;
844 pSMB->Timeout = 0;
845 pSMB->Reserved2 = 0;
846 param_offset = offsetof(struct smb_com_transaction2_spi_req,
847 InformationLevel) - 4;
848 offset = param_offset + params;
849
850 /* Setup pointer to Request Data (inode type) */
851 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
852 pRqD->type = cpu_to_le16(type);
853 pSMB->ParameterOffset = cpu_to_le16(param_offset);
854 pSMB->DataOffset = cpu_to_le16(offset);
855 pSMB->SetupCount = 1;
856 pSMB->Reserved3 = 0;
857 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
858 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
859
860 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
861 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
862 pSMB->ParameterCount = cpu_to_le16(params);
863 pSMB->TotalParameterCount = pSMB->ParameterCount;
864 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
865 pSMB->Reserved4 = 0;
be8e3b00 866 inc_rfc1001_len(pSMB, byte_count);
2d785a50
SF		 867 pSMB->ByteCount = cpu_to_le16(byte_count);
868 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
869 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 870 if (rc)
b6b38f70 871 cFYI(1, "Posix delete returned %d", rc);
2d785a50
SF		 872 cifs_buf_release(pSMB);
873
874 cifs_stats_inc(&tcon->num_deletes);
875
876 if (rc == -EAGAIN)
877 goto PsxDelete;
878
879 return rc;
880}
881
1da177e4 882int
96daf2b0 883CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
737b758c 884 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 885{
886 DELETE_FILE_REQ *pSMB = NULL;
887 DELETE_FILE_RSP *pSMBr = NULL;
888 int rc = 0;
889 int bytes_returned;
890 int name_len;
891
892DelFileRetry:
893 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
894 (void **) &pSMBr);
895 if (rc)
896 return rc;
897
898 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
899 name_len =
acbbb76a
SF		 900 cifsConvertToUTF16((__le16 *) pSMB->fileName, fileName,
901 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 902 name_len++; /* trailing null */
903 name_len *= 2;
09d1db5c 904 } else { /* BB improve check for buffer overruns BB */
1da177e4
LT		 905 name_len = strnlen(fileName, PATH_MAX);
906 name_len++; /* trailing null */
907 strncpy(pSMB->fileName, fileName, name_len);
908 }
909 pSMB->SearchAttributes =
910 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
911 pSMB->BufferFormat = 0x04;
be8e3b00 912 inc_rfc1001_len(pSMB, name_len + 1);
1da177e4
LT		 913 pSMB->ByteCount = cpu_to_le16(name_len + 1);
914 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
915 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 916 cifs_stats_inc(&tcon->num_deletes);
ad7a2926 917 if (rc)
b6b38f70 918 cFYI(1, "Error in RMFile = %d", rc);
1da177e4
LT		 919
920 cifs_buf_release(pSMB);
921 if (rc == -EAGAIN)
922 goto DelFileRetry;
923
924 return rc;
925}
926
927int
96daf2b0 928CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
737b758c 929 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 930{
931 DELETE_DIRECTORY_REQ *pSMB = NULL;
932 DELETE_DIRECTORY_RSP *pSMBr = NULL;
933 int rc = 0;
934 int bytes_returned;
935 int name_len;
936
b6b38f70 937 cFYI(1, "In CIFSSMBRmDir");
1da177e4
LT		 938RmDirRetry:
939 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
940 (void **) &pSMBr);
941 if (rc)
942 return rc;
943
944 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
acbbb76a
SF		 945 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, dirName,
946 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 947 name_len++; /* trailing null */
948 name_len *= 2;
09d1db5c 949 } else { /* BB improve check for buffer overruns BB */
1da177e4
LT		 950 name_len = strnlen(dirName, PATH_MAX);
951 name_len++; /* trailing null */
952 strncpy(pSMB->DirName, dirName, name_len);
953 }
954
955 pSMB->BufferFormat = 0x04;
be8e3b00 956 inc_rfc1001_len(pSMB, name_len + 1);
1da177e4
LT		 957 pSMB->ByteCount = cpu_to_le16(name_len + 1);
958 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
959 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 960 cifs_stats_inc(&tcon->num_rmdirs);
ad7a2926 961 if (rc)
b6b38f70 962 cFYI(1, "Error in RMDir = %d", rc);
1da177e4
LT		 963
964 cifs_buf_release(pSMB);
965 if (rc == -EAGAIN)
966 goto RmDirRetry;
967 return rc;
968}
969
970int
96daf2b0 971CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
737b758c 972 const char *name, const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 973{
974 int rc = 0;
975 CREATE_DIRECTORY_REQ *pSMB = NULL;
976 CREATE_DIRECTORY_RSP *pSMBr = NULL;
977 int bytes_returned;
978 int name_len;
979
b6b38f70 980 cFYI(1, "In CIFSSMBMkDir");
1da177e4
LT		 981MkDirRetry:
982 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
983 (void **) &pSMBr);
984 if (rc)
985 return rc;
986
987 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
acbbb76a
SF		 988 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
989 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 990 name_len++; /* trailing null */
991 name_len *= 2;
09d1db5c 992 } else { /* BB improve check for buffer overruns BB */
1da177e4
LT		 993 name_len = strnlen(name, PATH_MAX);
994 name_len++; /* trailing null */
995 strncpy(pSMB->DirName, name, name_len);
996 }
997
998 pSMB->BufferFormat = 0x04;
be8e3b00 999 inc_rfc1001_len(pSMB, name_len + 1);
1da177e4
LT		 1000 pSMB->ByteCount = cpu_to_le16(name_len + 1);
1001 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1002 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 1003 cifs_stats_inc(&tcon->num_mkdirs);
ad7a2926 1004 if (rc)
b6b38f70 1005 cFYI(1, "Error in Mkdir = %d", rc);
a5a2b489 1006
1da177e4
LT		 1007 cifs_buf_release(pSMB);
1008 if (rc == -EAGAIN)
1009 goto MkDirRetry;
1010 return rc;
1011}
1012
2dd29d31 1013int
96daf2b0 1014CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
ad7a2926 1015 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
50c2f753 1016 __u32 *pOplock, const char *name,
2dd29d31
SF		 1017 const struct nls_table *nls_codepage, int remap)
1018{
1019 TRANSACTION2_SPI_REQ *pSMB = NULL;
1020 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1021 int name_len;
1022 int rc = 0;
1023 int bytes_returned = 0;
2dd29d31 1024 __u16 params, param_offset, offset, byte_count, count;
ad7a2926
SF		 1025 OPEN_PSX_REQ *pdata;
1026 OPEN_PSX_RSP *psx_rsp;
2dd29d31 1027
b6b38f70 1028 cFYI(1, "In POSIX Create");
2dd29d31
SF		 1029PsxCreat:
1030 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1031 (void **) &pSMBr);
1032 if (rc)
1033 return rc;
1034
1035 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1036 name_len =
acbbb76a
SF		 1037 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1038 PATH_MAX, nls_codepage, remap);
2dd29d31
SF		 1039 name_len++; /* trailing null */
1040 name_len *= 2;
1041 } else { /* BB improve the check for buffer overruns BB */
1042 name_len = strnlen(name, PATH_MAX);
1043 name_len++; /* trailing null */
1044 strncpy(pSMB->FileName, name, name_len);
1045 }
1046
1047 params = 6 + name_len;
1048 count = sizeof(OPEN_PSX_REQ);
1049 pSMB->MaxParameterCount = cpu_to_le16(2);
1050 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1051 pSMB->MaxSetupCount = 0;
1052 pSMB->Reserved = 0;
1053 pSMB->Flags = 0;
1054 pSMB->Timeout = 0;
1055 pSMB->Reserved2 = 0;
1056 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 1057 InformationLevel) - 4;
2dd29d31 1058 offset = param_offset + params;
2dd29d31 1059 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
8f2376ad 1060 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
2dd29d31 1061 pdata->Permissions = cpu_to_le64(mode);
50c2f753 1062 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
2dd29d31
SF		 1063 pdata->OpenFlags = cpu_to_le32(*pOplock);
1064 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1065 pSMB->DataOffset = cpu_to_le16(offset);
1066 pSMB->SetupCount = 1;
1067 pSMB->Reserved3 = 0;
1068 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1069 byte_count = 3 /* pad */ + params + count;
1070
1071 pSMB->DataCount = cpu_to_le16(count);
1072 pSMB->ParameterCount = cpu_to_le16(params);
1073 pSMB->TotalDataCount = pSMB->DataCount;
1074 pSMB->TotalParameterCount = pSMB->ParameterCount;
1075 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1076 pSMB->Reserved4 = 0;
be8e3b00 1077 inc_rfc1001_len(pSMB, byte_count);
2dd29d31
SF		 1078 pSMB->ByteCount = cpu_to_le16(byte_count);
1079 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1080 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1081 if (rc) {
b6b38f70 1082 cFYI(1, "Posix create returned %d", rc);
2dd29d31
SF		 1083 goto psx_create_err;
1084 }
1085
b6b38f70 1086 cFYI(1, "copying inode info");
2dd29d31
SF		 1087 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1088
820a803f 1089 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
2dd29d31
SF		 1090 rc = -EIO; /* bad smb */
1091 goto psx_create_err;
1092 }
1093
1094 /* copy return information to pRetData */
50c2f753 1095 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
2dd29d31 1096 + le16_to_cpu(pSMBr->t2.DataOffset));
50c2f753 1097
2dd29d31 1098 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
790fe579 1099 if (netfid)
2dd29d31
SF		 1100 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1101 /* Let caller know file was created so we can set the mode. */
1102 /* Do we care about the CreateAction in any other cases? */
790fe579 1103 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
2dd29d31
SF		 1104 *pOplock |= CIFS_CREATE_ACTION;
1105 /* check to make sure response data is there */
8f2376ad
CG		 1106 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1107 pRetData->Type = cpu_to_le32(-1); /* unknown */
b6b38f70 1108 cFYI(DBG2, "unknown type");
cbac3cba 1109 } else {
820a803f 1110 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
2dd29d31 1111 + sizeof(FILE_UNIX_BASIC_INFO)) {
b6b38f70 1112 cERROR(1, "Open response data too small");
8f2376ad 1113 pRetData->Type = cpu_to_le32(-1);
2dd29d31
SF		 1114 goto psx_create_err;
1115 }
50c2f753 1116 memcpy((char *) pRetData,
cbac3cba 1117 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
26f57364 1118 sizeof(FILE_UNIX_BASIC_INFO));
2dd29d31 1119 }
2dd29d31
SF		 1120
1121psx_create_err:
1122 cifs_buf_release(pSMB);
1123
65bc98b0
SF		 1124 if (posix_flags & SMB_O_DIRECTORY)
1125 cifs_stats_inc(&tcon->num_posixmkdirs);
1126 else
1127 cifs_stats_inc(&tcon->num_posixopens);
2dd29d31
SF		 1128
1129 if (rc == -EAGAIN)
1130 goto PsxCreat;
1131
50c2f753 1132 return rc;
2dd29d31
SF		 1133}
1134
a9d02ad4
SF		 1135static __u16 convert_disposition(int disposition)
1136{
1137 __u16 ofun = 0;
1138
1139 switch (disposition) {
1140 case FILE_SUPERSEDE:
1141 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1142 break;
1143 case FILE_OPEN:
1144 ofun = SMBOPEN_OAPPEND;
1145 break;
1146 case FILE_CREATE:
1147 ofun = SMBOPEN_OCREATE;
1148 break;
1149 case FILE_OPEN_IF:
1150 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1151 break;
1152 case FILE_OVERWRITE:
1153 ofun = SMBOPEN_OTRUNC;
1154 break;
1155 case FILE_OVERWRITE_IF:
1156 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1157 break;
1158 default:
b6b38f70 1159 cFYI(1, "unknown disposition %d", disposition);
a9d02ad4
SF		 1160 ofun = SMBOPEN_OAPPEND; /* regular open */
1161 }
1162 return ofun;
1163}
1164
35fc37d5
JL		 1165static int
1166access_flags_to_smbopen_mode(const int access_flags)
1167{
1168 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1169
1170 if (masked_flags == GENERIC_READ)
1171 return SMBOPEN_READ;
1172 else if (masked_flags == GENERIC_WRITE)
1173 return SMBOPEN_WRITE;
1174
1175 /* just go for read/write */
1176 return SMBOPEN_READWRITE;
1177}
1178
a9d02ad4 1179int
96daf2b0 1180SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
a9d02ad4 1181 const char *fileName, const int openDisposition,
ad7a2926
SF		 1182 const int access_flags, const int create_options, __u16 *netfid,
1183 int *pOplock, FILE_ALL_INFO *pfile_info,
a9d02ad4
SF		 1184 const struct nls_table *nls_codepage, int remap)
1185{
1186 int rc = -EACCES;
1187 OPENX_REQ *pSMB = NULL;
1188 OPENX_RSP *pSMBr = NULL;
1189 int bytes_returned;
1190 int name_len;
1191 __u16 count;
1192
1193OldOpenRetry:
1194 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1195 (void **) &pSMBr);
1196 if (rc)
1197 return rc;
1198
1199 pSMB->AndXCommand = 0xFF; /* none */
1200
1201 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1202 count = 1; /* account for one byte pad to word boundary */
1203 name_len =
acbbb76a
SF		 1204 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1205 fileName, PATH_MAX, nls_codepage, remap);
a9d02ad4
SF		 1206 name_len++; /* trailing null */
1207 name_len *= 2;
1208 } else { /* BB improve check for buffer overruns BB */
1209 count = 0; /* no pad */
1210 name_len = strnlen(fileName, PATH_MAX);
1211 name_len++; /* trailing null */
1212 strncpy(pSMB->fileName, fileName, name_len);
1213 }
1214 if (*pOplock & REQ_OPLOCK)
1215 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
26f57364 1216 else if (*pOplock & REQ_BATCHOPLOCK)
a9d02ad4 1217 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
26f57364 1218
a9d02ad4 1219 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
35fc37d5 1220 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
a9d02ad4
SF		 1221 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1222 /* set file as system file if special file such
1223 as fifo and server expecting SFU style and
1224 no Unix extensions */
1225
790fe579
SF		 1226 if (create_options & CREATE_OPTION_SPECIAL)
1227 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
ad7a2926
SF		 1228 else /* BB FIXME BB */
1229 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
a9d02ad4 1230
67750fb9
JL		 1231 if (create_options & CREATE_OPTION_READONLY)
1232 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
a9d02ad4
SF		 1233
1234 /* BB FIXME BB */
50c2f753
SF		 1235/* pSMB->CreateOptions = cpu_to_le32(create_options &
1236 CREATE_OPTIONS_MASK); */
a9d02ad4 1237 /* BB FIXME END BB */
3e87d803
SF		 1238
1239 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
70ca734a 1240 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
a9d02ad4 1241 count += name_len;
be8e3b00 1242 inc_rfc1001_len(pSMB, count);
a9d02ad4
SF		 1243
1244 pSMB->ByteCount = cpu_to_le16(count);
1245 /* long_op set to 1 to allow for oplock break timeouts */
1246 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
7749981e 1247 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
a9d02ad4
SF		 1248 cifs_stats_inc(&tcon->num_opens);
1249 if (rc) {
b6b38f70 1250 cFYI(1, "Error in Open = %d", rc);
a9d02ad4
SF		 1251 } else {
1252 /* BB verify if wct == 15 */
1253
582d21e5 1254/* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
a9d02ad4
SF		 1255
1256 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1257 /* Let caller know file was created so we can set the mode. */
1258 /* Do we care about the CreateAction in any other cases? */
1259 /* BB FIXME BB */
790fe579 1260/* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
a9d02ad4
SF		 1261 *pOplock |= CIFS_CREATE_ACTION; */
1262 /* BB FIXME END */
1263
790fe579 1264 if (pfile_info) {
a9d02ad4
SF		 1265 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1266 pfile_info->LastAccessTime = 0; /* BB fixme */
1267 pfile_info->LastWriteTime = 0; /* BB fixme */
1268 pfile_info->ChangeTime = 0; /* BB fixme */
70ca734a 1269 pfile_info->Attributes =
50c2f753 1270 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
a9d02ad4 1271 /* the file_info buf is endian converted by caller */
70ca734a
SF		 1272 pfile_info->AllocationSize =
1273 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1274 pfile_info->EndOfFile = pfile_info->AllocationSize;
a9d02ad4 1275 pfile_info->NumberOfLinks = cpu_to_le32(1);
9a8165fc 1276 pfile_info->DeletePending = 0;
a9d02ad4
SF		 1277 }
1278 }
1279
1280 cifs_buf_release(pSMB);
1281 if (rc == -EAGAIN)
1282 goto OldOpenRetry;
1283 return rc;
1284}
1285
1da177e4 1286int
96daf2b0 1287CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
1da177e4 1288 const char *fileName, const int openDisposition,
ad7a2926
SF		 1289 const int access_flags, const int create_options, __u16 *netfid,
1290 int *pOplock, FILE_ALL_INFO *pfile_info,
737b758c 1291 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 1292{
1293 int rc = -EACCES;
1294 OPEN_REQ *pSMB = NULL;
1295 OPEN_RSP *pSMBr = NULL;
1296 int bytes_returned;
1297 int name_len;
1298 __u16 count;
1299
1300openRetry:
1301 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1302 (void **) &pSMBr);
1303 if (rc)
1304 return rc;
1305
1306 pSMB->AndXCommand = 0xFF; /* none */
1307
1308 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1309 count = 1; /* account for one byte pad to word boundary */
1310 name_len =
acbbb76a
SF		 1311 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1312 fileName, PATH_MAX, nls_codepage, remap);
1da177e4
LT		 1313 name_len++; /* trailing null */
1314 name_len *= 2;
1315 pSMB->NameLength = cpu_to_le16(name_len);
09d1db5c 1316 } else { /* BB improve check for buffer overruns BB */
1da177e4
LT		 1317 count = 0; /* no pad */
1318 name_len = strnlen(fileName, PATH_MAX);
1319 name_len++; /* trailing null */
1320 pSMB->NameLength = cpu_to_le16(name_len);
1321 strncpy(pSMB->fileName, fileName, name_len);
1322 }
1323 if (*pOplock & REQ_OPLOCK)
1324 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
26f57364 1325 else if (*pOplock & REQ_BATCHOPLOCK)
1da177e4 1326 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1da177e4
LT		 1327 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1328 pSMB->AllocationSize = 0;
eda3c029
SF		 1329 /* set file as system file if special file such
1330 as fifo and server expecting SFU style and
1331 no Unix extensions */
790fe579 1332 if (create_options & CREATE_OPTION_SPECIAL)
eda3c029
SF		 1333 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1334 else
1335 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
67750fb9 1336
1da177e4
LT		 1337 /* XP does not handle ATTR_POSIX_SEMANTICS */
1338 /* but it helps speed up case sensitive checks for other
1339 servers such as Samba */
1340 if (tcon->ses->capabilities & CAP_UNIX)
1341 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1342
67750fb9
JL		 1343 if (create_options & CREATE_OPTION_READONLY)
1344 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1345
1da177e4
LT		 1346 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1347 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
eda3c029 1348 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
09d1db5c
SF		 1349 /* BB Expirement with various impersonation levels and verify */
1350 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1da177e4
LT		 1351 pSMB->SecurityFlags =
1352 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1353
1354 count += name_len;
be8e3b00 1355 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 1356
1357 pSMB->ByteCount = cpu_to_le16(count);
1358 /* long_op set to 1 to allow for oplock break timeouts */
1359 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
7749981e 1360 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
a4544347 1361 cifs_stats_inc(&tcon->num_opens);
1da177e4 1362 if (rc) {
b6b38f70 1363 cFYI(1, "Error in Open = %d", rc);
1da177e4 1364 } else {
09d1db5c 1365 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1da177e4
LT		 1366 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1367 /* Let caller know file was created so we can set the mode. */
1368 /* Do we care about the CreateAction in any other cases? */
790fe579 1369 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
50c2f753 1370 *pOplock |= CIFS_CREATE_ACTION;
790fe579 1371 if (pfile_info) {
61e74801
SF		 1372 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1373 36 /* CreationTime to Attributes */);
1374 /* the file_info buf is endian converted by caller */
1375 pfile_info->AllocationSize = pSMBr->AllocationSize;
1376 pfile_info->EndOfFile = pSMBr->EndOfFile;
1377 pfile_info->NumberOfLinks = cpu_to_le32(1);
1378 pfile_info->DeletePending = 0;
1da177e4 1379 }
1da177e4 1380 }
a5a2b489 1381
1da177e4
LT		 1382 cifs_buf_release(pSMB);
1383 if (rc == -EAGAIN)
1384 goto openRetry;
1385 return rc;
1386}
1387
e28bc5b1
JL		 1388struct cifs_readdata *
1389cifs_readdata_alloc(unsigned int nr_pages)
1390{
1391 struct cifs_readdata *rdata;
1392
1393 /* readdata + 1 kvec for each page */
1394 rdata = kzalloc(sizeof(*rdata) +
1395 sizeof(struct kvec) * nr_pages, GFP_KERNEL);
1396 if (rdata != NULL) {
1397 INIT_WORK(&rdata->work, cifs_readv_complete);
1398 INIT_LIST_HEAD(&rdata->pages);
1399 }
1400 return rdata;
1401}
1402
1403void
1404cifs_readdata_free(struct cifs_readdata *rdata)
1405{
1406 cifsFileInfo_put(rdata->cfile);
1407 kfree(rdata);
1408}
1409
1410/*
1411 * Discard any remaining data in the current SMB. To do this, we borrow the
1412 * current bigbuf.
1413 */
1414static int
1415cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1416{
5ffef7bf 1417 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
e28bc5b1
JL		 1418 int remaining = rfclen + 4 - server->total_read;
1419 struct cifs_readdata *rdata = mid->callback_data;
1420
1421 while (remaining > 0) {
1422 int length;
1423
1424 length = cifs_read_from_socket(server, server->bigbuf,
1425 min_t(unsigned int, remaining,
5ffef7bf 1426 CIFSMaxBufSize + max_header_size()));
e28bc5b1
JL		 1427 if (length < 0)
1428 return length;
1429 server->total_read += length;
1430 remaining -= length;
1431 }
1432
1433 dequeue_mid(mid, rdata->result);
1434 return 0;
1435}
1436
5ffef7bf
PS		 1437static inline size_t
1438read_rsp_size(void)
1439{
1440 return sizeof(READ_RSP);
1441}
1442
1443static inline unsigned int
1444read_data_offset(char *buf)
1445{
1446 READ_RSP *rsp = (READ_RSP *)buf;
1447 return le16_to_cpu(rsp->DataOffset);
1448}
1449
1450static inline unsigned int
1451read_data_length(char *buf)
1452{
1453 READ_RSP *rsp = (READ_RSP *)buf;
1454 return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
1455 le16_to_cpu(rsp->DataLength);
1456}
1457
e28bc5b1
JL		 1458static int
1459cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1460{
1461 int length, len;
1462 unsigned int data_offset, remaining, data_len;
1463 struct cifs_readdata *rdata = mid->callback_data;
5ffef7bf
PS		 1464 char *buf = server->smallbuf;
1465 unsigned int buflen = get_rfc1002_length(buf) + 4;
e28bc5b1
JL		 1466 u64 eof;
1467 pgoff_t eof_index;
1468 struct page *page, *tpage;
1469
7c9421e1 1470 cFYI(1, "%s: mid=%llu offset=%llu bytes=%u", __func__,
e28bc5b1
JL		 1471 mid->mid, rdata->offset, rdata->bytes);
1472
1473 /*
1474 * read the rest of READ_RSP header (sans Data array), or whatever we
1475 * can if there's not enough data. At this point, we've read down to
1476 * the Mid.
1477 */
5ffef7bf 1478 len = min_t(unsigned int, buflen, read_rsp_size()) - header_size() + 1;
e28bc5b1 1479
5ffef7bf 1480 rdata->iov[0].iov_base = buf + header_size() - 1;
e28bc5b1
JL		 1481 rdata->iov[0].iov_len = len;
1482
1483 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1484 if (length < 0)
1485 return length;
1486 server->total_read += length;
1487
1488 /* Was the SMB read successful? */
5ffef7bf 1489 rdata->result = map_smb_to_linux_error(buf, false);
e28bc5b1
JL		 1490 if (rdata->result != 0) {
1491 cFYI(1, "%s: server returned error %d", __func__,
1492 rdata->result);
1493 return cifs_readv_discard(server, mid);
1494 }
1495
1496 /* Is there enough to get to the rest of the READ_RSP header? */
5ffef7bf 1497 if (server->total_read < read_rsp_size()) {
e28bc5b1 1498 cFYI(1, "%s: server returned short header. got=%u expected=%zu",
5ffef7bf 1499 __func__, server->total_read, read_rsp_size());
e28bc5b1
JL		 1500 rdata->result = -EIO;
1501 return cifs_readv_discard(server, mid);
1502 }
1503
5ffef7bf 1504 data_offset = read_data_offset(buf) + 4;
e28bc5b1
JL		 1505 if (data_offset < server->total_read) {
1506 /*
1507 * win2k8 sometimes sends an offset of 0 when the read
1508 * is beyond the EOF. Treat it as if the data starts just after
1509 * the header.
1510 */
1511 cFYI(1, "%s: data offset (%u) inside read response header",
1512 __func__, data_offset);
1513 data_offset = server->total_read;
1514 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1515 /* data_offset is beyond the end of smallbuf */
1516 cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
1517 __func__, data_offset);
1518 rdata->result = -EIO;
1519 return cifs_readv_discard(server, mid);
1520 }
1521
1522 cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
1523 server->total_read, data_offset);
1524
1525 len = data_offset - server->total_read;
1526 if (len > 0) {
1527 /* read any junk before data into the rest of smallbuf */
5ffef7bf 1528 rdata->iov[0].iov_base = buf + server->total_read;
e28bc5b1
JL		 1529 rdata->iov[0].iov_len = len;
1530 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1531 if (length < 0)
1532 return length;
1533 server->total_read += length;
1534 }
1535
1536 /* set up first iov for signature check */
5ffef7bf 1537 rdata->iov[0].iov_base = buf;
e28bc5b1
JL		 1538 rdata->iov[0].iov_len = server->total_read;
1539 cFYI(1, "0: iov_base=%p iov_len=%zu",
1540 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1541
1542 /* how much data is in the response? */
5ffef7bf
PS		 1543 data_len = read_data_length(buf);
1544 if (data_offset + data_len > buflen) {
e28bc5b1
JL		 1545 /* data_len is corrupt -- discard frame */
1546 rdata->result = -EIO;
1547 return cifs_readv_discard(server, mid);
1548 }
1549
1550 /* marshal up the page array */
1551 len = 0;
1552 remaining = data_len;
1553 rdata->nr_iov = 1;
1554
1555 /* determine the eof that the server (probably) has */
1556 eof = CIFS_I(rdata->mapping->host)->server_eof;
1557 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
1558 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
1559
1560 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1561 if (remaining >= PAGE_CACHE_SIZE) {
1562 /* enough data to fill the page */
1563 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1564 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
1565 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1566 rdata->nr_iov, page->index,
1567 rdata->iov[rdata->nr_iov].iov_base,
1568 rdata->iov[rdata->nr_iov].iov_len);
1569 ++rdata->nr_iov;
1570 len += PAGE_CACHE_SIZE;
1571 remaining -= PAGE_CACHE_SIZE;
1572 } else if (remaining > 0) {
1573 /* enough for partial page, fill and zero the rest */
1574 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1575 rdata->iov[rdata->nr_iov].iov_len = remaining;
1576 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1577 rdata->nr_iov, page->index,
1578 rdata->iov[rdata->nr_iov].iov_base,
1579 rdata->iov[rdata->nr_iov].iov_len);
1580 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
1581 '\0', PAGE_CACHE_SIZE - remaining);
1582 ++rdata->nr_iov;
1583 len += remaining;
1584 remaining = 0;
1585 } else if (page->index > eof_index) {
1586 /*
1587 * The VFS will not try to do readahead past the
1588 * i_size, but it's possible that we have outstanding
1589 * writes with gaps in the middle and the i_size hasn't
1590 * caught up yet. Populate those with zeroed out pages
1591 * to prevent the VFS from repeatedly attempting to
1592 * fill them until the writes are flushed.
1593 */
1594 zero_user(page, 0, PAGE_CACHE_SIZE);
1595 list_del(&page->lru);
1596 lru_cache_add_file(page);
1597 flush_dcache_page(page);
1598 SetPageUptodate(page);
1599 unlock_page(page);
1600 page_cache_release(page);
1601 } else {
1602 /* no need to hold page hostage */
1603 list_del(&page->lru);
1604 lru_cache_add_file(page);
1605 unlock_page(page);
1606 page_cache_release(page);
1607 }
1608 }
1609
1610 /* issue the read if we have any iovecs left to fill */
1611 if (rdata->nr_iov > 1) {
1612 length = cifs_readv_from_socket(server, &rdata->iov[1],
1613 rdata->nr_iov - 1, len);
1614 if (length < 0)
1615 return length;
1616 server->total_read += length;
1617 } else {
1618 length = 0;
1619 }
1620
1621 rdata->bytes = length;
1622
5ffef7bf
PS		 1623 cFYI(1, "total_read=%u buflen=%u remaining=%u", server->total_read,
1624 buflen, remaining);
e28bc5b1
JL		 1625
1626 /* discard anything left over */
5ffef7bf 1627 if (server->total_read < buflen)
e28bc5b1
JL		 1628 return cifs_readv_discard(server, mid);
1629
1630 dequeue_mid(mid, false);
1631 return length;
1632}
1633
1634static void
1635cifs_readv_complete(struct work_struct *work)
1636{
1637 struct cifs_readdata *rdata = container_of(work,
1638 struct cifs_readdata, work);
1639 struct page *page, *tpage;
1640
1641 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1642 list_del(&page->lru);
1643 lru_cache_add_file(page);
e28bc5b1
JL		 1644
1645 if (rdata->result == 0) {
a2d6b6ca 1646 kunmap(page);
e28bc5b1
JL		 1647 flush_dcache_page(page);
1648 SetPageUptodate(page);
1649 }
1650
1651 unlock_page(page);
1652
1653 if (rdata->result == 0)
1654 cifs_readpage_to_fscache(rdata->mapping->host, page);
1655
1656 page_cache_release(page);
1657 }
1658 cifs_readdata_free(rdata);
1659}
1660
1661static void
1662cifs_readv_callback(struct mid_q_entry *mid)
1663{
1664 struct cifs_readdata *rdata = mid->callback_data;
1665 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1666 struct TCP_Server_Info *server = tcon->ses->server;
1667
7c9421e1
PS		 1668 cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
1669 mid->mid, mid->mid_state, rdata->result, rdata->bytes);
e28bc5b1 1670
7c9421e1 1671 switch (mid->mid_state) {
e28bc5b1
JL		 1672 case MID_RESPONSE_RECEIVED:
1673 /* result already set, check signature */
1674 if (server->sec_mode &
1675 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1676 if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
1677 server, mid->sequence_number + 1))
1678 cERROR(1, "Unexpected SMB signature");
1679 }
1680 /* FIXME: should this be counted toward the initiating task? */
1681 task_io_account_read(rdata->bytes);
1682 cifs_stats_bytes_read(tcon, rdata->bytes);
1683 break;
1684 case MID_REQUEST_SUBMITTED:
1685 case MID_RETRY_NEEDED:
1686 rdata->result = -EAGAIN;
1687 break;
1688 default:
1689 rdata->result = -EIO;
1690 }
1691
da472fc8 1692 queue_work(cifsiod_wq, &rdata->work);
e28bc5b1 1693 DeleteMidQEntry(mid);
2d86dbc9 1694 cifs_add_credits(server, 1);
e28bc5b1
JL		 1695}
1696
1697/* cifs_async_readv - send an async write, and set up mid to handle result */
1698int
1699cifs_async_readv(struct cifs_readdata *rdata)
1700{
1701 int rc;
1702 READ_REQ *smb = NULL;
1703 int wct;
1704 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1705
1706 cFYI(1, "%s: offset=%llu bytes=%u", __func__,
1707 rdata->offset, rdata->bytes);
1708
1709 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1710 wct = 12;
1711 else {
1712 wct = 10; /* old style read */
1713 if ((rdata->offset >> 32) > 0) {
1714 /* can not handle this big offset for old */
1715 return -EIO;
1716 }
1717 }
1718
1719 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1720 if (rc)
1721 return rc;
1722
1723 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1724 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1725
1726 smb->AndXCommand = 0xFF; /* none */
1727 smb->Fid = rdata->cfile->netfid;
1728 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1729 if (wct == 12)
1730 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1731 smb->Remaining = 0;
1732 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1733 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1734 if (wct == 12)
1735 smb->ByteCount = 0;
1736 else {
1737 /* old style read */
1738 struct smb_com_readx_req *smbr =
1739 (struct smb_com_readx_req *)smb;
1740 smbr->ByteCount = 0;
1741 }
1742
1743 /* 4 for RFC1001 length + 1 for BCC */
1744 rdata->iov[0].iov_base = smb;
1745 rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1746
1747 rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
1748 cifs_readv_receive, cifs_readv_callback,
1749 rdata, false);
1750
1751 if (rc == 0)
1752 cifs_stats_inc(&tcon->num_reads);
1753
1754 cifs_small_buf_release(smb);
1755 return rc;
1756}
1757
1da177e4 1758int
d4ffff1f 1759CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
50c2f753 1760 char **buf, int *pbuf_type)
1da177e4
LT		 1761{
1762 int rc = -EACCES;
1763 READ_REQ *pSMB = NULL;
1764 READ_RSP *pSMBr = NULL;
1765 char *pReadData = NULL;
bfa0d75a 1766 int wct;
ec637e3f
SF		 1767 int resp_buf_type = 0;
1768 struct kvec iov[1];
d4ffff1f
PS		 1769 __u32 pid = io_parms->pid;
1770 __u16 netfid = io_parms->netfid;
1771 __u64 offset = io_parms->offset;
96daf2b0 1772 struct cifs_tcon *tcon = io_parms->tcon;
d4ffff1f 1773 unsigned int count = io_parms->length;
1da177e4 1774
b6b38f70 1775 cFYI(1, "Reading %d bytes on fid %d", count, netfid);
790fe579 1776 if (tcon->ses->capabilities & CAP_LARGE_FILES)
bfa0d75a 1777 wct = 12;
4c3130ef 1778 else {
bfa0d75a 1779 wct = 10; /* old style read */
d4ffff1f 1780 if ((offset >> 32) > 0) {
4c3130ef
SF		 1781 /* can not handle this big offset for old */
1782 return -EIO;
1783 }
1784 }
1da177e4
LT		 1785
1786 *nbytes = 0;
ec637e3f 1787 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1da177e4
LT		 1788 if (rc)
1789 return rc;
1790
d4ffff1f
PS		 1791 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1792 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1793
1da177e4
LT		 1794 /* tcon and ses pointer are checked in smb_init */
1795 if (tcon->ses->server == NULL)
1796 return -ECONNABORTED;
1797
ec637e3f 1798 pSMB->AndXCommand = 0xFF; /* none */
1da177e4 1799 pSMB->Fid = netfid;
d4ffff1f 1800 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
790fe579 1801 if (wct == 12)
d4ffff1f 1802 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
bfa0d75a 1803
1da177e4
LT		 1804 pSMB->Remaining = 0;
1805 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1806 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
790fe579 1807 if (wct == 12)
bfa0d75a
SF		 1808 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1809 else {
1810 /* old style read */
50c2f753 1811 struct smb_com_readx_req *pSMBW =
bfa0d75a 1812 (struct smb_com_readx_req *)pSMB;
ec637e3f 1813 pSMBW->ByteCount = 0;
bfa0d75a 1814 }
ec637e3f
SF		 1815
1816 iov[0].iov_base = (char *)pSMB;
be8e3b00 1817 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
a761ac57 1818 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
7749981e 1819 &resp_buf_type, CIFS_LOG_ERROR);
a4544347 1820 cifs_stats_inc(&tcon->num_reads);
ec637e3f 1821 pSMBr = (READ_RSP *)iov[0].iov_base;
1da177e4 1822 if (rc) {
b6b38f70 1823 cERROR(1, "Send error in read = %d", rc);
1da177e4
LT		 1824 } else {
1825 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1826 data_length = data_length << 16;
1827 data_length += le16_to_cpu(pSMBr->DataLength);
1828 *nbytes = data_length;
1829
1830 /*check that DataLength would not go beyond end of SMB */
ec637e3f 1831 if ((data_length > CIFSMaxBufSize)
1da177e4 1832 || (data_length > count)) {
b6b38f70
JP		 1833 cFYI(1, "bad length %d for count %d",
1834 data_length, count);
1da177e4
LT		 1835 rc = -EIO;
1836 *nbytes = 0;
1837 } else {
ec637e3f 1838 pReadData = (char *) (&pSMBr->hdr.Protocol) +
26f57364
SF		 1839 le16_to_cpu(pSMBr->DataOffset);
1840/* if (rc = copy_to_user(buf, pReadData, data_length)) {
b6b38f70 1841 cERROR(1, "Faulting on read rc = %d",rc);
50c2f753 1842 rc = -EFAULT;
26f57364 1843 }*/ /* can not use copy_to_user when using page cache*/
790fe579 1844 if (*buf)
50c2f753 1845 memcpy(*buf, pReadData, data_length);
1da177e4
LT		 1846 }
1847 }
1da177e4 1848
4b8f930f 1849/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
790fe579
SF		 1850 if (*buf) {
1851 if (resp_buf_type == CIFS_SMALL_BUFFER)
ec637e3f 1852 cifs_small_buf_release(iov[0].iov_base);
790fe579 1853 else if (resp_buf_type == CIFS_LARGE_BUFFER)
ec637e3f 1854 cifs_buf_release(iov[0].iov_base);
790fe579 1855 } else if (resp_buf_type != CIFS_NO_BUFFER) {
50c2f753
SF		 1856 /* return buffer to caller to free */
1857 *buf = iov[0].iov_base;
790fe579 1858 if (resp_buf_type == CIFS_SMALL_BUFFER)
ec637e3f 1859 *pbuf_type = CIFS_SMALL_BUFFER;
790fe579 1860 else if (resp_buf_type == CIFS_LARGE_BUFFER)
ec637e3f 1861 *pbuf_type = CIFS_LARGE_BUFFER;
6cec2aed 1862 } /* else no valid buffer on return - leave as null */
ec637e3f
SF		 1863
1864 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 1865 since file handle passed in no longer valid */
1866 return rc;
1867}
1868
ec637e3f 1869
1da177e4 1870int
fa2989f4
PS		 1871CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
1872 unsigned int *nbytes, const char *buf,
50c2f753 1873 const char __user *ubuf, const int long_op)
1da177e4
LT		 1874{
1875 int rc = -EACCES;
1876 WRITE_REQ *pSMB = NULL;
1877 WRITE_RSP *pSMBr = NULL;
1c955187 1878 int bytes_returned, wct;
1da177e4
LT		 1879 __u32 bytes_sent;
1880 __u16 byte_count;
fa2989f4
PS		 1881 __u32 pid = io_parms->pid;
1882 __u16 netfid = io_parms->netfid;
1883 __u64 offset = io_parms->offset;
96daf2b0 1884 struct cifs_tcon *tcon = io_parms->tcon;
fa2989f4 1885 unsigned int count = io_parms->length;
1da177e4 1886
a24e2d7d
SF		 1887 *nbytes = 0;
1888
b6b38f70 1889 /* cFYI(1, "write at %lld %d bytes", offset, count);*/
790fe579 1890 if (tcon->ses == NULL)
1c955187
SF		 1891 return -ECONNABORTED;
1892
790fe579 1893 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1c955187 1894 wct = 14;
4c3130ef 1895 else {
1c955187 1896 wct = 12;
4c3130ef
SF		 1897 if ((offset >> 32) > 0) {
1898 /* can not handle big offset for old srv */
1899 return -EIO;
1900 }
1901 }
1c955187
SF		 1902
1903 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1da177e4
LT		 1904 (void **) &pSMBr);
1905 if (rc)
1906 return rc;
fa2989f4
PS		 1907
1908 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1909 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1910
1da177e4
LT		 1911 /* tcon and ses pointer are checked in smb_init */
1912 if (tcon->ses->server == NULL)
1913 return -ECONNABORTED;
1914
1915 pSMB->AndXCommand = 0xFF; /* none */
1916 pSMB->Fid = netfid;
1917 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
790fe579 1918 if (wct == 14)
1c955187 1919 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
50c2f753 1920
1da177e4
LT		 1921 pSMB->Reserved = 0xFFFFFFFF;
1922 pSMB->WriteMode = 0;
1923 pSMB->Remaining = 0;
1924
50c2f753 1925 /* Can increase buffer size if buffer is big enough in some cases ie we
1da177e4
LT		 1926 can send more if LARGE_WRITE_X capability returned by the server and if
1927 our buffer is big enough or if we convert to iovecs on socket writes
1928 and eliminate the copy to the CIFS buffer */
790fe579 1929 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1da177e4
LT		 1930 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1931 } else {
1932 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1933 & ~0xFF;
1934 }
1935
1936 if (bytes_sent > count)
1937 bytes_sent = count;
1938 pSMB->DataOffset =
50c2f753 1939 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
790fe579 1940 if (buf)
61e74801 1941 memcpy(pSMB->Data, buf, bytes_sent);
790fe579
SF		 1942 else if (ubuf) {
1943 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1da177e4
LT		 1944 cifs_buf_release(pSMB);
1945 return -EFAULT;
1946 }
e30dcf3a 1947 } else if (count != 0) {
1da177e4
LT		 1948 /* No buffer */
1949 cifs_buf_release(pSMB);
1950 return -EINVAL;
e30dcf3a 1951 } /* else setting file size with write of zero bytes */
790fe579 1952 if (wct == 14)
e30dcf3a 1953 byte_count = bytes_sent + 1; /* pad */
ad7a2926 1954 else /* wct == 12 */
e30dcf3a 1955 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
ad7a2926 1956
1da177e4
LT		 1957 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1958 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
be8e3b00 1959 inc_rfc1001_len(pSMB, byte_count);
1c955187 1960
790fe579 1961 if (wct == 14)
1c955187 1962 pSMB->ByteCount = cpu_to_le16(byte_count);
50c2f753
SF		 1963 else { /* old style write has byte count 4 bytes earlier
1964 so 4 bytes pad */
1965 struct smb_com_writex_req *pSMBW =
1c955187
SF		 1966 (struct smb_com_writex_req *)pSMB;
1967 pSMBW->ByteCount = cpu_to_le16(byte_count);
1968 }
1da177e4
LT		 1969
1970 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1971 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
a4544347 1972 cifs_stats_inc(&tcon->num_writes);
1da177e4 1973 if (rc) {
f19159dc 1974 cFYI(1, "Send error in write = %d", rc);
1da177e4
LT		 1975 } else {
1976 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1977 *nbytes = (*nbytes) << 16;
1978 *nbytes += le16_to_cpu(pSMBr->Count);
6513a81e
SJ		 1979
1980 /*
1981 * Mask off high 16 bits when bytes written as returned by the
1982 * server is greater than bytes requested by the client. Some
1983 * OS/2 servers are known to set incorrect CountHigh values.
1984 */
1985 if (*nbytes > count)
1986 *nbytes &= 0xFFFF;
1da177e4
LT		 1987 }
1988
1989 cifs_buf_release(pSMB);
1990
50c2f753 1991 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 1992 since file handle passed in no longer valid */
1993
1994 return rc;
1995}
1996
c28c89fc
JL		 1997void
1998cifs_writedata_release(struct kref *refcount)
1999{
2000 struct cifs_writedata *wdata = container_of(refcount,
2001 struct cifs_writedata, refcount);
2002
2003 if (wdata->cfile)
2004 cifsFileInfo_put(wdata->cfile);
2005
2006 kfree(wdata);
2007}
2008
2009/*
2010 * Write failed with a retryable error. Resend the write request. It's also
2011 * possible that the page was redirtied so re-clean the page.
2012 */
2013static void
2014cifs_writev_requeue(struct cifs_writedata *wdata)
2015{
2016 int i, rc;
2017 struct inode *inode = wdata->cfile->dentry->d_inode;
2018
2019 for (i = 0; i < wdata->nr_pages; i++) {
2020 lock_page(wdata->pages[i]);
2021 clear_page_dirty_for_io(wdata->pages[i]);
2022 }
2023
2024 do {
2025 rc = cifs_async_writev(wdata);
2026 } while (rc == -EAGAIN);
2027
2028 for (i = 0; i < wdata->nr_pages; i++) {
2029 if (rc != 0)
2030 SetPageError(wdata->pages[i]);
2031 unlock_page(wdata->pages[i]);
2032 }
2033
2034 mapping_set_error(inode->i_mapping, rc);
2035 kref_put(&wdata->refcount, cifs_writedata_release);
2036}
2037
c2e87640 2038void
c28c89fc
JL		 2039cifs_writev_complete(struct work_struct *work)
2040{
2041 struct cifs_writedata *wdata = container_of(work,
2042 struct cifs_writedata, work);
2043 struct inode *inode = wdata->cfile->dentry->d_inode;
2044 int i = 0;
2045
2046 if (wdata->result == 0) {
2047 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2048 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2049 wdata->bytes);
2050 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2051 return cifs_writev_requeue(wdata);
2052
2053 for (i = 0; i < wdata->nr_pages; i++) {
2054 struct page *page = wdata->pages[i];
2055 if (wdata->result == -EAGAIN)
2056 __set_page_dirty_nobuffers(page);
2057 else if (wdata->result < 0)
2058 SetPageError(page);
2059 end_page_writeback(page);
2060 page_cache_release(page);
2061 }
2062 if (wdata->result != -EAGAIN)
2063 mapping_set_error(inode->i_mapping, wdata->result);
2064 kref_put(&wdata->refcount, cifs_writedata_release);
2065}
2066
2067struct cifs_writedata *
c2e87640 2068cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
c28c89fc
JL		 2069{
2070 struct cifs_writedata *wdata;
2071
2072 /* this would overflow */
2073 if (nr_pages == 0) {
2074 cERROR(1, "%s: called with nr_pages == 0!", __func__);
2075 return NULL;
2076 }
2077
2078 /* writedata + number of page pointers */
2079 wdata = kzalloc(sizeof(*wdata) +
2080 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
2081 if (wdata != NULL) {
c2e87640 2082 INIT_WORK(&wdata->work, complete);
c28c89fc
JL		 2083 kref_init(&wdata->refcount);
2084 }
2085 return wdata;
2086}
2087
2088/*
7c9421e1 2089 * Check the mid_state and signature on received buffer (if any), and queue the
c28c89fc
JL		 2090 * workqueue completion task.
2091 */
2092static void
2093cifs_writev_callback(struct mid_q_entry *mid)
2094{
2095 struct cifs_writedata *wdata = mid->callback_data;
96daf2b0 2096 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
c28c89fc
JL		 2097 unsigned int written;
2098 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2099
7c9421e1 2100 switch (mid->mid_state) {
c28c89fc
JL		 2101 case MID_RESPONSE_RECEIVED:
2102 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2103 if (wdata->result != 0)
2104 break;
2105
2106 written = le16_to_cpu(smb->CountHigh);
2107 written <<= 16;
2108 written += le16_to_cpu(smb->Count);
2109 /*
2110 * Mask off high 16 bits when bytes written as returned
2111 * by the server is greater than bytes requested by the
2112 * client. OS/2 servers are known to set incorrect
2113 * CountHigh values.
2114 */
2115 if (written > wdata->bytes)
2116 written &= 0xFFFF;
2117
2118 if (written < wdata->bytes)
2119 wdata->result = -ENOSPC;
2120 else
2121 wdata->bytes = written;
2122 break;
2123 case MID_REQUEST_SUBMITTED:
2124 case MID_RETRY_NEEDED:
2125 wdata->result = -EAGAIN;
2126 break;
2127 default:
2128 wdata->result = -EIO;
2129 break;
2130 }
2131
da472fc8 2132 queue_work(cifsiod_wq, &wdata->work);
c28c89fc 2133 DeleteMidQEntry(mid);
2d86dbc9 2134 cifs_add_credits(tcon->ses->server, 1);
c28c89fc
JL		 2135}
2136
2137/* cifs_async_writev - send an async write, and set up mid to handle result */
2138int
2139cifs_async_writev(struct cifs_writedata *wdata)
2140{
2141 int i, rc = -EACCES;
2142 WRITE_REQ *smb = NULL;
2143 int wct;
96daf2b0 2144 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
c28c89fc
JL		 2145 struct kvec *iov = NULL;
2146
2147 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2148 wct = 14;
2149 } else {
2150 wct = 12;
2151 if (wdata->offset >> 32 > 0) {
2152 /* can not handle big offset for old srv */
2153 return -EIO;
2154 }
2155 }
2156
2157 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2158 if (rc)
2159 goto async_writev_out;
2160
2161 /* 1 iov per page + 1 for header */
2162 iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
2163 if (iov == NULL) {
2164 rc = -ENOMEM;
2165 goto async_writev_out;
2166 }
2167
fe5f5d2e
JL		 2168 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2169 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
fa2989f4 2170
c28c89fc
JL		 2171 smb->AndXCommand = 0xFF; /* none */
2172 smb->Fid = wdata->cfile->netfid;
2173 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2174 if (wct == 14)
2175 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2176 smb->Reserved = 0xFFFFFFFF;
2177 smb->WriteMode = 0;
2178 smb->Remaining = 0;
2179
2180 smb->DataOffset =
2181 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2182
2183 /* 4 for RFC1001 length + 1 for BCC */
2184 iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2185 iov[0].iov_base = smb;
2186
e9492871
JL		 2187 /*
2188 * This function should marshal up the page array into the kvec
2189 * array, reserving [0] for the header. It should kmap the pages
2190 * and set the iov_len properly for each one. It may also set
2191 * wdata->bytes too.
2192 */
2193 wdata->marshal_iov(iov, wdata);
c28c89fc
JL		 2194
2195 cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
2196
2197 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2198 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2199
2200 if (wct == 14) {
2201 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2202 put_bcc(wdata->bytes + 1, &smb->hdr);
2203 } else {
2204 /* wct == 12 */
2205 struct smb_com_writex_req *smbw =
2206 (struct smb_com_writex_req *)smb;
2207 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2208 put_bcc(wdata->bytes + 5, &smbw->hdr);
2209 iov[0].iov_len += 4; /* pad bigger by four bytes */
2210 }
2211
2212 kref_get(&wdata->refcount);
2213 rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
44d22d84 2214 NULL, cifs_writev_callback, wdata, false);
c28c89fc
JL		 2215
2216 if (rc == 0)
2217 cifs_stats_inc(&tcon->num_writes);
2218 else
2219 kref_put(&wdata->refcount, cifs_writedata_release);
2220
2221 /* send is done, unmap pages */
2222 for (i = 0; i < wdata->nr_pages; i++)
2223 kunmap(wdata->pages[i]);
2224
2225async_writev_out:
2226 cifs_small_buf_release(smb);
2227 kfree(iov);
2228 return rc;
2229}
2230
d6e04ae6 2231int
fa2989f4
PS		 2232CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
2233 unsigned int *nbytes, struct kvec *iov, int n_vec,
2234 const int long_op)
1da177e4
LT		 2235{
2236 int rc = -EACCES;
2237 WRITE_REQ *pSMB = NULL;
ec637e3f 2238 int wct;
d6e04ae6 2239 int smb_hdr_len;
ec637e3f 2240 int resp_buf_type = 0;
fa2989f4
PS		 2241 __u32 pid = io_parms->pid;
2242 __u16 netfid = io_parms->netfid;
2243 __u64 offset = io_parms->offset;
96daf2b0 2244 struct cifs_tcon *tcon = io_parms->tcon;
fa2989f4 2245 unsigned int count = io_parms->length;
1da177e4 2246
fbec9ab9
JL		 2247 *nbytes = 0;
2248
b6b38f70 2249 cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
ff7feac9 2250
4c3130ef 2251 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
8cc64c6e 2252 wct = 14;
4c3130ef 2253 } else {
8cc64c6e 2254 wct = 12;
4c3130ef
SF		 2255 if ((offset >> 32) > 0) {
2256 /* can not handle big offset for old srv */
2257 return -EIO;
2258 }
2259 }
8cc64c6e 2260 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1da177e4
LT		 2261 if (rc)
2262 return rc;
fa2989f4
PS		 2263
2264 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2265 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2266
1da177e4
LT		 2267 /* tcon and ses pointer are checked in smb_init */
2268 if (tcon->ses->server == NULL)
2269 return -ECONNABORTED;
2270
d6e04ae6 2271 pSMB->AndXCommand = 0xFF; /* none */
1da177e4
LT		 2272 pSMB->Fid = netfid;
2273 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
790fe579 2274 if (wct == 14)
8cc64c6e 2275 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1da177e4
LT		 2276 pSMB->Reserved = 0xFFFFFFFF;
2277 pSMB->WriteMode = 0;
2278 pSMB->Remaining = 0;
d6e04ae6 2279
1da177e4 2280 pSMB->DataOffset =
50c2f753 2281 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1da177e4 2282
3e84469d
SF		 2283 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2284 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
be8e3b00
SF		 2285 /* header + 1 byte pad */
2286 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
790fe579 2287 if (wct == 14)
be8e3b00 2288 inc_rfc1001_len(pSMB, count + 1);
8cc64c6e 2289 else /* wct == 12 */
be8e3b00 2290 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
790fe579 2291 if (wct == 14)
8cc64c6e
SF		 2292 pSMB->ByteCount = cpu_to_le16(count + 1);
2293 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
50c2f753 2294 struct smb_com_writex_req *pSMBW =
8cc64c6e
SF		 2295 (struct smb_com_writex_req *)pSMB;
2296 pSMBW->ByteCount = cpu_to_le16(count + 5);
2297 }
3e84469d 2298 iov[0].iov_base = pSMB;
790fe579 2299 if (wct == 14)
ec637e3f
SF		 2300 iov[0].iov_len = smb_hdr_len + 4;
2301 else /* wct == 12 pad bigger by four bytes */
2302 iov[0].iov_len = smb_hdr_len + 8;
50c2f753 2303
1da177e4 2304
ec637e3f 2305 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
133672ef 2306 long_op);
a4544347 2307 cifs_stats_inc(&tcon->num_writes);
1da177e4 2308 if (rc) {
b6b38f70 2309 cFYI(1, "Send error Write2 = %d", rc);
790fe579 2310 } else if (resp_buf_type == 0) {
ec637e3f
SF		 2311 /* presumably this can not happen, but best to be safe */
2312 rc = -EIO;
d6e04ae6 2313 } else {
ad7a2926 2314 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
d6e04ae6
SF		 2315 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2316 *nbytes = (*nbytes) << 16;
2317 *nbytes += le16_to_cpu(pSMBr->Count);
6513a81e
SJ		 2318
2319 /*
2320 * Mask off high 16 bits when bytes written as returned by the
2321 * server is greater than bytes requested by the client. OS/2
2322 * servers are known to set incorrect CountHigh values.
2323 */
2324 if (*nbytes > count)
2325 *nbytes &= 0xFFFF;
50c2f753 2326 }
1da177e4 2327
4b8f930f 2328/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
790fe579 2329 if (resp_buf_type == CIFS_SMALL_BUFFER)
ec637e3f 2330 cifs_small_buf_release(iov[0].iov_base);
790fe579 2331 else if (resp_buf_type == CIFS_LARGE_BUFFER)
ec637e3f 2332 cifs_buf_release(iov[0].iov_base);
1da177e4 2333
50c2f753 2334 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 2335 since file handle passed in no longer valid */
2336
2337 return rc;
2338}
d6e04ae6 2339
9ee305b7
PS		 2340int cifs_lockv(const int xid, struct cifs_tcon *tcon, const __u16 netfid,
2341 const __u8 lock_type, const __u32 num_unlock,
2342 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2343{
2344 int rc = 0;
2345 LOCK_REQ *pSMB = NULL;
2346 struct kvec iov[2];
2347 int resp_buf_type;
2348 __u16 count;
2349
2350 cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
2351
2352 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2353 if (rc)
2354 return rc;
2355
2356 pSMB->Timeout = 0;
2357 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2358 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2359 pSMB->LockType = lock_type;
2360 pSMB->AndXCommand = 0xFF; /* none */
2361 pSMB->Fid = netfid; /* netfid stays le */
2362
2363 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2364 inc_rfc1001_len(pSMB, count);
2365 pSMB->ByteCount = cpu_to_le16(count);
2366
2367 iov[0].iov_base = (char *)pSMB;
2368 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2369 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2370 iov[1].iov_base = (char *)buf;
2371 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2372
2373 cifs_stats_inc(&tcon->num_locks);
2374 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2375 if (rc)
2376 cFYI(1, "Send error in cifs_lockv = %d", rc);
2377
2378 return rc;
2379}
d6e04ae6 2380
1da177e4 2381int
96daf2b0 2382CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
03776f45 2383 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
1da177e4 2384 const __u64 offset, const __u32 numUnlock,
12fed00d
PS		 2385 const __u32 numLock, const __u8 lockType,
2386 const bool waitFlag, const __u8 oplock_level)
1da177e4
LT		 2387{
2388 int rc = 0;
2389 LOCK_REQ *pSMB = NULL;
aaa9bbe0 2390/* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
1da177e4
LT		 2391 int bytes_returned;
2392 int timeout = 0;
2393 __u16 count;
2394
b6b38f70 2395 cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
46810cbf
SF		 2396 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2397
1da177e4
LT		 2398 if (rc)
2399 return rc;
2400
790fe579 2401 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
133672ef 2402 timeout = CIFS_ASYNC_OP; /* no response expected */
1da177e4 2403 pSMB->Timeout = 0;
4b18f2a9 2404 } else if (waitFlag) {
133672ef 2405 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1da177e4
LT		 2406 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2407 } else {
2408 pSMB->Timeout = 0;
2409 }
2410
2411 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2412 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2413 pSMB->LockType = lockType;
12fed00d 2414 pSMB->OplockLevel = oplock_level;
1da177e4
LT		 2415 pSMB->AndXCommand = 0xFF; /* none */
2416 pSMB->Fid = smb_file_id; /* netfid stays le */
2417
790fe579 2418 if ((numLock != 0) || (numUnlock != 0)) {
03776f45 2419 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
1da177e4
LT		 2420 /* BB where to store pid high? */
2421 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2422 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2423 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2424 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2425 count = sizeof(LOCKING_ANDX_RANGE);
2426 } else {
2427 /* oplock break */
2428 count = 0;
2429 }
be8e3b00 2430 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 2431 pSMB->ByteCount = cpu_to_le16(count);
2432
7ee1af76
JA		 2433 if (waitFlag) {
2434 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
aaa9bbe0 2435 (struct smb_hdr *) pSMB, &bytes_returned);
133672ef 2436 cifs_small_buf_release(pSMB);
7ee1af76 2437 } else {
792af7b0 2438 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, timeout);
133672ef 2439 /* SMB buffer freed by function above */
7ee1af76 2440 }
a4544347 2441 cifs_stats_inc(&tcon->num_locks);
ad7a2926 2442 if (rc)
b6b38f70 2443 cFYI(1, "Send error in Lock = %d", rc);
1da177e4 2444
50c2f753 2445 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 2446 since file handle passed in no longer valid */
2447 return rc;
2448}
2449
08547b03 2450int
96daf2b0 2451CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
4f6bcec9
PS		 2452 const __u16 smb_file_id, const __u32 netpid, const int get_flag,
2453 const __u64 len, struct file_lock *pLockData,
2454 const __u16 lock_type, const bool waitFlag)
08547b03
SF		 2455{
2456 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2457 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
08547b03
SF		 2458 struct cifs_posix_lock *parm_data;
2459 int rc = 0;
3a5ff61c 2460 int timeout = 0;
08547b03 2461 int bytes_returned = 0;
133672ef 2462 int resp_buf_type = 0;
08547b03 2463 __u16 params, param_offset, offset, byte_count, count;
133672ef 2464 struct kvec iov[1];
08547b03 2465
b6b38f70 2466 cFYI(1, "Posix Lock");
fc94cdb9 2467
790fe579 2468 if (pLockData == NULL)
ed5f0370 2469 return -EINVAL;
fc94cdb9 2470
08547b03
SF		 2471 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2472
2473 if (rc)
2474 return rc;
2475
2476 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2477
50c2f753 2478 params = 6;
08547b03
SF		 2479 pSMB->MaxSetupCount = 0;
2480 pSMB->Reserved = 0;
2481 pSMB->Flags = 0;
08547b03
SF		 2482 pSMB->Reserved2 = 0;
2483 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2484 offset = param_offset + params;
2485
08547b03
SF		 2486 count = sizeof(struct cifs_posix_lock);
2487 pSMB->MaxParameterCount = cpu_to_le16(2);
ad7a2926 2488 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
08547b03
SF		 2489 pSMB->SetupCount = 1;
2490 pSMB->Reserved3 = 0;
790fe579 2491 if (get_flag)
08547b03
SF		 2492 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2493 else
2494 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2495 byte_count = 3 /* pad */ + params + count;
2496 pSMB->DataCount = cpu_to_le16(count);
2497 pSMB->ParameterCount = cpu_to_le16(params);
2498 pSMB->TotalDataCount = pSMB->DataCount;
2499 pSMB->TotalParameterCount = pSMB->ParameterCount;
2500 pSMB->ParameterOffset = cpu_to_le16(param_offset);
50c2f753 2501 parm_data = (struct cifs_posix_lock *)
08547b03
SF		 2502 (((char *) &pSMB->hdr.Protocol) + offset);
2503
2504 parm_data->lock_type = cpu_to_le16(lock_type);
790fe579 2505 if (waitFlag) {
133672ef 2506 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
cec6815a 2507 parm_data->lock_flags = cpu_to_le16(1);
3a5ff61c
SF		 2508 pSMB->Timeout = cpu_to_le32(-1);
2509 } else
2510 pSMB->Timeout = 0;
2511
4f6bcec9 2512 parm_data->pid = cpu_to_le32(netpid);
fc94cdb9 2513 parm_data->start = cpu_to_le64(pLockData->fl_start);
cec6815a 2514 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
08547b03
SF		 2515
2516 pSMB->DataOffset = cpu_to_le16(offset);
f26282c9 2517 pSMB->Fid = smb_file_id;
08547b03
SF		 2518 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2519 pSMB->Reserved4 = 0;
be8e3b00 2520 inc_rfc1001_len(pSMB, byte_count);
08547b03 2521 pSMB->ByteCount = cpu_to_le16(byte_count);
7ee1af76
JA		 2522 if (waitFlag) {
2523 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2524 (struct smb_hdr *) pSMBr, &bytes_returned);
2525 } else {
133672ef 2526 iov[0].iov_base = (char *)pSMB;
be8e3b00 2527 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
133672ef
SF		 2528 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2529 &resp_buf_type, timeout);
2530 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2531 not try to free it twice below on exit */
2532 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
7ee1af76
JA		 2533 }
2534
08547b03 2535 if (rc) {
b6b38f70 2536 cFYI(1, "Send error in Posix Lock = %d", rc);
fc94cdb9
SF		 2537 } else if (get_flag) {
2538 /* lock structure can be returned on get */
2539 __u16 data_offset;
2540 __u16 data_count;
2541 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2542
820a803f 2543 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
fc94cdb9
SF		 2544 rc = -EIO; /* bad smb */
2545 goto plk_err_exit;
2546 }
fc94cdb9
SF		 2547 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2548 data_count = le16_to_cpu(pSMBr->t2.DataCount);
790fe579 2549 if (data_count < sizeof(struct cifs_posix_lock)) {
fc94cdb9
SF		 2550 rc = -EIO;
2551 goto plk_err_exit;
2552 }
2553 parm_data = (struct cifs_posix_lock *)
2554 ((char *)&pSMBr->hdr.Protocol + data_offset);
f05337c6 2555 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
fc94cdb9 2556 pLockData->fl_type = F_UNLCK;
f05337c6
PS		 2557 else {
2558 if (parm_data->lock_type ==
2559 __constant_cpu_to_le16(CIFS_RDLCK))
2560 pLockData->fl_type = F_RDLCK;
2561 else if (parm_data->lock_type ==
2562 __constant_cpu_to_le16(CIFS_WRLCK))
2563 pLockData->fl_type = F_WRLCK;
2564
5443d130
SF		 2565 pLockData->fl_start = le64_to_cpu(parm_data->start);
2566 pLockData->fl_end = pLockData->fl_start +
2567 le64_to_cpu(parm_data->length) - 1;
2568 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
f05337c6 2569 }
08547b03 2570 }
50c2f753 2571
fc94cdb9 2572plk_err_exit:
08547b03
SF		 2573 if (pSMB)
2574 cifs_small_buf_release(pSMB);
2575
133672ef
SF		 2576 if (resp_buf_type == CIFS_SMALL_BUFFER)
2577 cifs_small_buf_release(iov[0].iov_base);
2578 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2579 cifs_buf_release(iov[0].iov_base);
2580
08547b03
SF		 2581 /* Note: On -EAGAIN error only caller can retry on handle based calls
2582 since file handle passed in no longer valid */
2583
2584 return rc;
2585}
2586
2587
1da177e4 2588int
96daf2b0 2589CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
1da177e4
LT		 2590{
2591 int rc = 0;
2592 CLOSE_REQ *pSMB = NULL;
b6b38f70 2593 cFYI(1, "In CIFSSMBClose");
1da177e4
LT		 2594
2595/* do not retry on dead session on close */
2596 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
790fe579 2597 if (rc == -EAGAIN)
1da177e4
LT		 2598 return 0;
2599 if (rc)
2600 return rc;
2601
1da177e4 2602 pSMB->FileID = (__u16) smb_file_id;
b815f1e5 2603 pSMB->LastWriteTime = 0xFFFFFFFF;
1da177e4 2604 pSMB->ByteCount = 0;
792af7b0 2605 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
a4544347 2606 cifs_stats_inc(&tcon->num_closes);
1da177e4 2607 if (rc) {
790fe579 2608 if (rc != -EINTR) {
1da177e4 2609 /* EINTR is expected when user ctl-c to kill app */
b6b38f70 2610 cERROR(1, "Send error in Close = %d", rc);
1da177e4
LT		 2611 }
2612 }
2613
1da177e4 2614 /* Since session is dead, file will be closed on server already */
790fe579 2615 if (rc == -EAGAIN)
1da177e4
LT		 2616 rc = 0;
2617
2618 return rc;
2619}
2620
b298f223 2621int
96daf2b0 2622CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
b298f223
SF		 2623{
2624 int rc = 0;
2625 FLUSH_REQ *pSMB = NULL;
b6b38f70 2626 cFYI(1, "In CIFSSMBFlush");
b298f223
SF		 2627
2628 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2629 if (rc)
2630 return rc;
2631
2632 pSMB->FileID = (__u16) smb_file_id;
2633 pSMB->ByteCount = 0;
792af7b0 2634 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
b298f223
SF		 2635 cifs_stats_inc(&tcon->num_flushes);
2636 if (rc)
b6b38f70 2637 cERROR(1, "Send error in Flush = %d", rc);
b298f223
SF		 2638
2639 return rc;
2640}
2641
1da177e4 2642int
96daf2b0 2643CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
1da177e4 2644 const char *fromName, const char *toName,
737b758c 2645 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 2646{
2647 int rc = 0;
2648 RENAME_REQ *pSMB = NULL;
2649 RENAME_RSP *pSMBr = NULL;
2650 int bytes_returned;
2651 int name_len, name_len2;
2652 __u16 count;
2653
b6b38f70 2654 cFYI(1, "In CIFSSMBRename");
1da177e4
LT		 2655renameRetry:
2656 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2657 (void **) &pSMBr);
2658 if (rc)
2659 return rc;
2660
2661 pSMB->BufferFormat = 0x04;
2662 pSMB->SearchAttributes =
2663 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2664 ATTR_DIRECTORY);
2665
2666 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2667 name_len =
acbbb76a
SF		 2668 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
2669 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 2670 name_len++; /* trailing null */
2671 name_len *= 2;
2672 pSMB->OldFileName[name_len] = 0x04; /* pad */
2673 /* protocol requires ASCII signature byte on Unicode string */
2674 pSMB->OldFileName[name_len + 1] = 0x00;
2675 name_len2 =
acbbb76a
SF		 2676 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2677 toName, PATH_MAX, nls_codepage, remap);
1da177e4
LT		 2678 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2679 name_len2 *= 2; /* convert to bytes */
50c2f753 2680 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2681 name_len = strnlen(fromName, PATH_MAX);
2682 name_len++; /* trailing null */
2683 strncpy(pSMB->OldFileName, fromName, name_len);
2684 name_len2 = strnlen(toName, PATH_MAX);
2685 name_len2++; /* trailing null */
2686 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2687 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2688 name_len2++; /* trailing null */
2689 name_len2++; /* signature byte */
2690 }
2691
2692 count = 1 /* 1st signature byte */ + name_len + name_len2;
be8e3b00 2693 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 2694 pSMB->ByteCount = cpu_to_le16(count);
2695
2696 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2697 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 2698 cifs_stats_inc(&tcon->num_renames);
ad7a2926 2699 if (rc)
b6b38f70 2700 cFYI(1, "Send error in rename = %d", rc);
1da177e4 2701
1da177e4
LT		 2702 cifs_buf_release(pSMB);
2703
2704 if (rc == -EAGAIN)
2705 goto renameRetry;
2706
2707 return rc;
2708}
2709
96daf2b0 2710int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
391e5755 2711 int netfid, const char *target_name,
50c2f753 2712 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 2713{
2714 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2715 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
50c2f753 2716 struct set_file_rename *rename_info;
1da177e4
LT		 2717 char *data_offset;
2718 char dummy_string[30];
2719 int rc = 0;
2720 int bytes_returned = 0;
2721 int len_of_str;
2722 __u16 params, param_offset, offset, count, byte_count;
2723
b6b38f70 2724 cFYI(1, "Rename to File by handle");
1da177e4
LT		 2725 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2726 (void **) &pSMBr);
2727 if (rc)
2728 return rc;
2729
2730 params = 6;
2731 pSMB->MaxSetupCount = 0;
2732 pSMB->Reserved = 0;
2733 pSMB->Flags = 0;
2734 pSMB->Timeout = 0;
2735 pSMB->Reserved2 = 0;
2736 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2737 offset = param_offset + params;
2738
2739 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2740 rename_info = (struct set_file_rename *) data_offset;
2741 pSMB->MaxParameterCount = cpu_to_le16(2);
ad7a2926 2742 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
1da177e4
LT		 2743 pSMB->SetupCount = 1;
2744 pSMB->Reserved3 = 0;
2745 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2746 byte_count = 3 /* pad */ + params;
2747 pSMB->ParameterCount = cpu_to_le16(params);
2748 pSMB->TotalParameterCount = pSMB->ParameterCount;
2749 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2750 pSMB->DataOffset = cpu_to_le16(offset);
2751 /* construct random name ".cifs_tmp<inodenum><mid>" */
2752 rename_info->overwrite = cpu_to_le32(1);
2753 rename_info->root_fid = 0;
2754 /* unicode only call */
790fe579 2755 if (target_name == NULL) {
50c2f753 2756 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
acbbb76a
SF		 2757 len_of_str =
2758 cifsConvertToUTF16((__le16 *)rename_info->target_name,
737b758c 2759 dummy_string, 24, nls_codepage, remap);
1da177e4 2760 } else {
acbbb76a
SF		 2761 len_of_str =
2762 cifsConvertToUTF16((__le16 *)rename_info->target_name,
50c2f753
SF		 2763 target_name, PATH_MAX, nls_codepage,
2764 remap);
1da177e4
LT		 2765 }
2766 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
391e5755 2767 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
1da177e4
LT		 2768 byte_count += count;
2769 pSMB->DataCount = cpu_to_le16(count);
2770 pSMB->TotalDataCount = pSMB->DataCount;
2771 pSMB->Fid = netfid;
2772 pSMB->InformationLevel =
2773 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2774 pSMB->Reserved4 = 0;
be8e3b00 2775 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 2776 pSMB->ByteCount = cpu_to_le16(byte_count);
2777 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
50c2f753 2778 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 2779 cifs_stats_inc(&pTcon->num_t2renames);
ad7a2926 2780 if (rc)
b6b38f70 2781 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
a5a2b489 2782
1da177e4
LT		 2783 cifs_buf_release(pSMB);
2784
2785 /* Note: On -EAGAIN error only caller can retry on handle based calls
2786 since file handle passed in no longer valid */
2787
2788 return rc;
2789}
2790
2791int
96daf2b0 2792CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
50c2f753
SF		 2793 const __u16 target_tid, const char *toName, const int flags,
2794 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 2795{
2796 int rc = 0;
2797 COPY_REQ *pSMB = NULL;
2798 COPY_RSP *pSMBr = NULL;
2799 int bytes_returned;
2800 int name_len, name_len2;
2801 __u16 count;
2802
b6b38f70 2803 cFYI(1, "In CIFSSMBCopy");
1da177e4
LT		 2804copyRetry:
2805 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2806 (void **) &pSMBr);
2807 if (rc)
2808 return rc;
2809
2810 pSMB->BufferFormat = 0x04;
2811 pSMB->Tid2 = target_tid;
2812
2813 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2814
2815 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
acbbb76a
SF		 2816 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2817 fromName, PATH_MAX, nls_codepage,
2818 remap);
1da177e4
LT		 2819 name_len++; /* trailing null */
2820 name_len *= 2;
2821 pSMB->OldFileName[name_len] = 0x04; /* pad */
2822 /* protocol requires ASCII signature byte on Unicode string */
2823 pSMB->OldFileName[name_len + 1] = 0x00;
50c2f753 2824 name_len2 =
acbbb76a
SF		 2825 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2826 toName, PATH_MAX, nls_codepage, remap);
1da177e4
LT		 2827 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2828 name_len2 *= 2; /* convert to bytes */
50c2f753 2829 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2830 name_len = strnlen(fromName, PATH_MAX);
2831 name_len++; /* trailing null */
2832 strncpy(pSMB->OldFileName, fromName, name_len);
2833 name_len2 = strnlen(toName, PATH_MAX);
2834 name_len2++; /* trailing null */
2835 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2836 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2837 name_len2++; /* trailing null */
2838 name_len2++; /* signature byte */
2839 }
2840
2841 count = 1 /* 1st signature byte */ + name_len + name_len2;
be8e3b00 2842 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 2843 pSMB->ByteCount = cpu_to_le16(count);
2844
2845 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2846 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2847 if (rc) {
b6b38f70
JP		 2848 cFYI(1, "Send error in copy = %d with %d files copied",
2849 rc, le16_to_cpu(pSMBr->CopyCount));
1da177e4 2850 }
0d817bc0 2851 cifs_buf_release(pSMB);
1da177e4
LT		 2852
2853 if (rc == -EAGAIN)
2854 goto copyRetry;
2855
2856 return rc;
2857}
2858
2859int
96daf2b0 2860CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
1da177e4
LT		 2861 const char *fromName, const char *toName,
2862 const struct nls_table *nls_codepage)
2863{
2864 TRANSACTION2_SPI_REQ *pSMB = NULL;
2865 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2866 char *data_offset;
2867 int name_len;
2868 int name_len_target;
2869 int rc = 0;
2870 int bytes_returned = 0;
2871 __u16 params, param_offset, offset, byte_count;
2872
b6b38f70 2873 cFYI(1, "In Symlink Unix style");
1da177e4
LT		 2874createSymLinkRetry:
2875 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2876 (void **) &pSMBr);
2877 if (rc)
2878 return rc;
2879
2880 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2881 name_len =
acbbb76a
SF		 2882 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2883 /* find define for this maxpathcomponent */
2884 PATH_MAX, nls_codepage);
1da177e4
LT		 2885 name_len++; /* trailing null */
2886 name_len *= 2;
2887
50c2f753 2888 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2889 name_len = strnlen(fromName, PATH_MAX);
2890 name_len++; /* trailing null */
2891 strncpy(pSMB->FileName, fromName, name_len);
2892 }
2893 params = 6 + name_len;
2894 pSMB->MaxSetupCount = 0;
2895 pSMB->Reserved = 0;
2896 pSMB->Flags = 0;
2897 pSMB->Timeout = 0;
2898 pSMB->Reserved2 = 0;
2899 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 2900 InformationLevel) - 4;
1da177e4
LT		 2901 offset = param_offset + params;
2902
2903 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2904 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2905 name_len_target =
acbbb76a
SF		 2906 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2907 /* find define for this maxpathcomponent */
2908 , nls_codepage);
1da177e4
LT		 2909 name_len_target++; /* trailing null */
2910 name_len_target *= 2;
50c2f753 2911 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2912 name_len_target = strnlen(toName, PATH_MAX);
2913 name_len_target++; /* trailing null */
2914 strncpy(data_offset, toName, name_len_target);
2915 }
2916
2917 pSMB->MaxParameterCount = cpu_to_le16(2);
2918 /* BB find exact max on data count below from sess */
2919 pSMB->MaxDataCount = cpu_to_le16(1000);
2920 pSMB->SetupCount = 1;
2921 pSMB->Reserved3 = 0;
2922 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2923 byte_count = 3 /* pad */ + params + name_len_target;
2924 pSMB->DataCount = cpu_to_le16(name_len_target);
2925 pSMB->ParameterCount = cpu_to_le16(params);
2926 pSMB->TotalDataCount = pSMB->DataCount;
2927 pSMB->TotalParameterCount = pSMB->ParameterCount;
2928 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2929 pSMB->DataOffset = cpu_to_le16(offset);
2930 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2931 pSMB->Reserved4 = 0;
be8e3b00 2932 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 2933 pSMB->ByteCount = cpu_to_le16(byte_count);
2934 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2935 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 2936 cifs_stats_inc(&tcon->num_symlinks);
ad7a2926 2937 if (rc)
b6b38f70 2938 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
1da177e4 2939
0d817bc0 2940 cifs_buf_release(pSMB);
1da177e4
LT		 2941
2942 if (rc == -EAGAIN)
2943 goto createSymLinkRetry;
2944
2945 return rc;
2946}
2947
2948int
96daf2b0 2949CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
1da177e4 2950 const char *fromName, const char *toName,
737b758c 2951 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 2952{
2953 TRANSACTION2_SPI_REQ *pSMB = NULL;
2954 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2955 char *data_offset;
2956 int name_len;
2957 int name_len_target;
2958 int rc = 0;
2959 int bytes_returned = 0;
2960 __u16 params, param_offset, offset, byte_count;
2961
b6b38f70 2962 cFYI(1, "In Create Hard link Unix style");
1da177e4
LT		 2963createHardLinkRetry:
2964 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2965 (void **) &pSMBr);
2966 if (rc)
2967 return rc;
2968
2969 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
acbbb76a
SF		 2970 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2971 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 2972 name_len++; /* trailing null */
2973 name_len *= 2;
2974
50c2f753 2975 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2976 name_len = strnlen(toName, PATH_MAX);
2977 name_len++; /* trailing null */
2978 strncpy(pSMB->FileName, toName, name_len);
2979 }
2980 params = 6 + name_len;
2981 pSMB->MaxSetupCount = 0;
2982 pSMB->Reserved = 0;
2983 pSMB->Flags = 0;
2984 pSMB->Timeout = 0;
2985 pSMB->Reserved2 = 0;
2986 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 2987 InformationLevel) - 4;
1da177e4
LT		 2988 offset = param_offset + params;
2989
2990 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2991 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2992 name_len_target =
acbbb76a
SF		 2993 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2994 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 2995 name_len_target++; /* trailing null */
2996 name_len_target *= 2;
50c2f753 2997 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 2998 name_len_target = strnlen(fromName, PATH_MAX);
2999 name_len_target++; /* trailing null */
3000 strncpy(data_offset, fromName, name_len_target);
3001 }
3002
3003 pSMB->MaxParameterCount = cpu_to_le16(2);
3004 /* BB find exact max on data count below from sess*/
3005 pSMB->MaxDataCount = cpu_to_le16(1000);
3006 pSMB->SetupCount = 1;
3007 pSMB->Reserved3 = 0;
3008 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3009 byte_count = 3 /* pad */ + params + name_len_target;
3010 pSMB->ParameterCount = cpu_to_le16(params);
3011 pSMB->TotalParameterCount = pSMB->ParameterCount;
3012 pSMB->DataCount = cpu_to_le16(name_len_target);
3013 pSMB->TotalDataCount = pSMB->DataCount;
3014 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3015 pSMB->DataOffset = cpu_to_le16(offset);
3016 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
3017 pSMB->Reserved4 = 0;
be8e3b00 3018 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 3019 pSMB->ByteCount = cpu_to_le16(byte_count);
3020 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3021 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 3022 cifs_stats_inc(&tcon->num_hardlinks);
ad7a2926 3023 if (rc)
b6b38f70 3024 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
1da177e4
LT		 3025
3026 cifs_buf_release(pSMB);
3027 if (rc == -EAGAIN)
3028 goto createHardLinkRetry;
3029
3030 return rc;
3031}
3032
3033int
96daf2b0 3034CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
1da177e4 3035 const char *fromName, const char *toName,
737b758c 3036 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 3037{
3038 int rc = 0;
3039 NT_RENAME_REQ *pSMB = NULL;
3040 RENAME_RSP *pSMBr = NULL;
3041 int bytes_returned;
3042 int name_len, name_len2;
3043 __u16 count;
3044
b6b38f70 3045 cFYI(1, "In CIFSCreateHardLink");
1da177e4
LT		 3046winCreateHardLinkRetry:
3047
3048 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
3049 (void **) &pSMBr);
3050 if (rc)
3051 return rc;
3052
3053 pSMB->SearchAttributes =
3054 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3055 ATTR_DIRECTORY);
3056 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
3057 pSMB->ClusterCount = 0;
3058
3059 pSMB->BufferFormat = 0x04;
3060
3061 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3062 name_len =
acbbb76a
SF		 3063 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
3064 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 3065 name_len++; /* trailing null */
3066 name_len *= 2;
fcc7c09d
JL		 3067
3068 /* protocol specifies ASCII buffer format (0x04) for unicode */
3069 pSMB->OldFileName[name_len] = 0x04;
3070 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
1da177e4 3071 name_len2 =
acbbb76a
SF		 3072 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3073 toName, PATH_MAX, nls_codepage, remap);
1da177e4
LT		 3074 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3075 name_len2 *= 2; /* convert to bytes */
50c2f753 3076 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 3077 name_len = strnlen(fromName, PATH_MAX);
3078 name_len++; /* trailing null */
3079 strncpy(pSMB->OldFileName, fromName, name_len);
3080 name_len2 = strnlen(toName, PATH_MAX);
3081 name_len2++; /* trailing null */
3082 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3083 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
3084 name_len2++; /* trailing null */
3085 name_len2++; /* signature byte */
3086 }
3087
3088 count = 1 /* string type byte */ + name_len + name_len2;
be8e3b00 3089 inc_rfc1001_len(pSMB, count);
1da177e4
LT		 3090 pSMB->ByteCount = cpu_to_le16(count);
3091
3092 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3093 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 3094 cifs_stats_inc(&tcon->num_hardlinks);
ad7a2926 3095 if (rc)
b6b38f70 3096 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
ad7a2926 3097
1da177e4
LT		 3098 cifs_buf_release(pSMB);
3099 if (rc == -EAGAIN)
3100 goto winCreateHardLinkRetry;
3101
3102 return rc;
3103}
3104
3105int
96daf2b0 3106CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
460b9696 3107 const unsigned char *searchName, char **symlinkinfo,
1da177e4
LT		 3108 const struct nls_table *nls_codepage)
3109{
3110/* SMB_QUERY_FILE_UNIX_LINK */
3111 TRANSACTION2_QPI_REQ *pSMB = NULL;
3112 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3113 int rc = 0;
3114 int bytes_returned;
3115 int name_len;
3116 __u16 params, byte_count;
460b9696 3117 char *data_start;
1da177e4 3118
b6b38f70 3119 cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
1da177e4
LT		 3120
3121querySymLinkRetry:
3122 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3123 (void **) &pSMBr);
3124 if (rc)
3125 return rc;
3126
3127 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3128 name_len =
acbbb76a
SF		 3129 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3130 PATH_MAX, nls_codepage);
1da177e4
LT		 3131 name_len++; /* trailing null */
3132 name_len *= 2;
50c2f753 3133 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 3134 name_len = strnlen(searchName, PATH_MAX);
3135 name_len++; /* trailing null */
3136 strncpy(pSMB->FileName, searchName, name_len);
3137 }
3138
3139 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3140 pSMB->TotalDataCount = 0;
3141 pSMB->MaxParameterCount = cpu_to_le16(2);
46a7574c 3142 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
1da177e4
LT		 3143 pSMB->MaxSetupCount = 0;
3144 pSMB->Reserved = 0;
3145 pSMB->Flags = 0;
3146 pSMB->Timeout = 0;
3147 pSMB->Reserved2 = 0;
3148 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 3149 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
1da177e4
LT		 3150 pSMB->DataCount = 0;
3151 pSMB->DataOffset = 0;
3152 pSMB->SetupCount = 1;
3153 pSMB->Reserved3 = 0;
3154 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3155 byte_count = params + 1 /* pad */ ;
3156 pSMB->TotalParameterCount = cpu_to_le16(params);
3157 pSMB->ParameterCount = pSMB->TotalParameterCount;
3158 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3159 pSMB->Reserved4 = 0;
be8e3b00 3160 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 3161 pSMB->ByteCount = cpu_to_le16(byte_count);
3162
3163 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3164 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3165 if (rc) {
b6b38f70 3166 cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
1da177e4
LT		 3167 } else {
3168 /* decode response */
3169
3170 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1da177e4 3171 /* BB also check enough total bytes returned */
820a803f 3172 if (rc || get_bcc(&pSMBr->hdr) < 2)
460b9696 3173 rc = -EIO;
1da177e4 3174 else {
0e0d2cf3 3175 bool is_unicode;
460b9696
JL		 3176 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3177
3178 data_start = ((char *) &pSMBr->hdr.Protocol) +
3179 le16_to_cpu(pSMBr->t2.DataOffset);
1da177e4 3180
0e0d2cf3
SF		 3181 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3182 is_unicode = true;
3183 else
3184 is_unicode = false;
3185
737b758c 3186 /* BB FIXME investigate remapping reserved chars here */
acbbb76a
SF		 3187 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3188 count, is_unicode, nls_codepage);
8b6427a2 3189 if (!*symlinkinfo)
460b9696 3190 rc = -ENOMEM;
1da177e4
LT		 3191 }
3192 }
3193 cifs_buf_release(pSMB);
3194 if (rc == -EAGAIN)
3195 goto querySymLinkRetry;
3196 return rc;
3197}
3198
c52a9554
SF		 3199#ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
3200/*
3201 * Recent Windows versions now create symlinks more frequently
3202 * and they use the "reparse point" mechanism below. We can of course
3203 * do symlinks nicely to Samba and other servers which support the
3204 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3205 * "MF" symlinks optionally, but for recent Windows we really need to
3206 * reenable the code below and fix the cifs_symlink callers to handle this.
3207 * In the interim this code has been moved to its own config option so
3208 * it is not compiled in by default until callers fixed up and more tested.
3209 */
1da177e4 3210int
96daf2b0 3211CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
1da177e4 3212 const unsigned char *searchName,
50c2f753 3213 char *symlinkinfo, const int buflen, __u16 fid,
1da177e4
LT		 3214 const struct nls_table *nls_codepage)
3215{
3216 int rc = 0;
3217 int bytes_returned;
50c2f753
SF		 3218 struct smb_com_transaction_ioctl_req *pSMB;
3219 struct smb_com_transaction_ioctl_rsp *pSMBr;
1da177e4 3220
b6b38f70 3221 cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
1da177e4
LT		 3222 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3223 (void **) &pSMBr);
3224 if (rc)
3225 return rc;
3226
3227 pSMB->TotalParameterCount = 0 ;
3228 pSMB->TotalDataCount = 0;
3229 pSMB->MaxParameterCount = cpu_to_le32(2);
3230 /* BB find exact data count max from sess structure BB */
c974befa 3231 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
1da177e4
LT		 3232 pSMB->MaxSetupCount = 4;
3233 pSMB->Reserved = 0;
3234 pSMB->ParameterOffset = 0;
3235 pSMB->DataCount = 0;
3236 pSMB->DataOffset = 0;
3237 pSMB->SetupCount = 4;
3238 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3239 pSMB->ParameterCount = pSMB->TotalParameterCount;
3240 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3241 pSMB->IsFsctl = 1; /* FSCTL */
3242 pSMB->IsRootFlag = 0;
3243 pSMB->Fid = fid; /* file handle always le */
3244 pSMB->ByteCount = 0;
3245
3246 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3247 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3248 if (rc) {
b6b38f70 3249 cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
1da177e4
LT		 3250 } else { /* decode response */
3251 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
3252 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
820a803f
JL		 3253 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3254 /* BB also check enough total bytes returned */
1da177e4 3255 rc = -EIO; /* bad smb */
afe48c31
SF		 3256 goto qreparse_out;
3257 }
3258 if (data_count && (data_count < 2048)) {
3259 char *end_of_smb = 2 /* sizeof byte count */ +
820a803f 3260 get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
1da177e4 3261
afe48c31 3262 struct reparse_data *reparse_buf =
50c2f753
SF		 3263 (struct reparse_data *)
3264 ((char *)&pSMBr->hdr.Protocol
3265 + data_offset);
afe48c31
SF		 3266 if ((char *)reparse_buf >= end_of_smb) {
3267 rc = -EIO;
3268 goto qreparse_out;
3269 }
3270 if ((reparse_buf->LinkNamesBuf +
3271 reparse_buf->TargetNameOffset +
3272 reparse_buf->TargetNameLen) > end_of_smb) {
b6b38f70 3273 cFYI(1, "reparse buf beyond SMB");
afe48c31
SF		 3274 rc = -EIO;
3275 goto qreparse_out;
3276 }
50c2f753 3277
afe48c31
SF		 3278 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3279 cifs_from_ucs2(symlinkinfo, (__le16 *)
50c2f753
SF		 3280 (reparse_buf->LinkNamesBuf +
3281 reparse_buf->TargetNameOffset),
afe48c31
SF		 3282 buflen,
3283 reparse_buf->TargetNameLen,
3284 nls_codepage, 0);
3285 } else { /* ASCII names */
3286 strncpy(symlinkinfo,
3287 reparse_buf->LinkNamesBuf +
3288 reparse_buf->TargetNameOffset,
3289 min_t(const int, buflen,
3290 reparse_buf->TargetNameLen));
1da177e4 3291 }
afe48c31
SF		 3292 } else {
3293 rc = -EIO;
b6b38f70
JP		 3294 cFYI(1, "Invalid return data count on "
3295 "get reparse info ioctl");
1da177e4 3296 }
afe48c31
SF		 3297 symlinkinfo[buflen] = 0; /* just in case so the caller
3298 does not go off the end of the buffer */
b6b38f70 3299 cFYI(1, "readlink result - %s", symlinkinfo);
1da177e4 3300 }
989c7e51 3301
1da177e4 3302qreparse_out:
4a6d87f1 3303 cifs_buf_release(pSMB);
1da177e4
LT		 3304
3305 /* Note: On -EAGAIN error only caller can retry on handle based calls
3306 since file handle passed in no longer valid */
3307
3308 return rc;
3309}
c52a9554 3310#endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
1da177e4
LT		 3311
3312#ifdef CONFIG_CIFS_POSIX
3313
3314/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
50c2f753
SF		 3315static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3316 struct cifs_posix_ace *cifs_ace)
1da177e4
LT		 3317{
3318 /* u8 cifs fields do not need le conversion */
ff7feac9
SF		 3319 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3320 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3321 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
b6b38f70 3322 /* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
1da177e4
LT		 3323
3324 return;
3325}
3326
3327/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
50c2f753
SF		 3328static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3329 const int acl_type, const int size_of_data_area)
1da177e4
LT		 3330{
3331 int size = 0;
3332 int i;
3333 __u16 count;
50c2f753
SF		 3334 struct cifs_posix_ace *pACE;
3335 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3336 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
1da177e4
LT		 3337
3338 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3339 return -EOPNOTSUPP;
3340
790fe579 3341 if (acl_type & ACL_TYPE_ACCESS) {
1da177e4
LT		 3342 count = le16_to_cpu(cifs_acl->access_entry_count);
3343 pACE = &cifs_acl->ace_array[0];
3344 size = sizeof(struct cifs_posix_acl);
3345 size += sizeof(struct cifs_posix_ace) * count;
3346 /* check if we would go beyond end of SMB */
790fe579 3347 if (size_of_data_area < size) {
b6b38f70
JP		 3348 cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
3349 size_of_data_area, size);
1da177e4
LT		 3350 return -EINVAL;
3351 }
790fe579 3352 } else if (acl_type & ACL_TYPE_DEFAULT) {
1da177e4
LT		 3353 count = le16_to_cpu(cifs_acl->access_entry_count);
3354 size = sizeof(struct cifs_posix_acl);
3355 size += sizeof(struct cifs_posix_ace) * count;
3356/* skip past access ACEs to get to default ACEs */
3357 pACE = &cifs_acl->ace_array[count];
3358 count = le16_to_cpu(cifs_acl->default_entry_count);
3359 size += sizeof(struct cifs_posix_ace) * count;
3360 /* check if we would go beyond end of SMB */
790fe579 3361 if (size_of_data_area < size)
1da177e4
LT		 3362 return -EINVAL;
3363 } else {
3364 /* illegal type */
3365 return -EINVAL;
3366 }
3367
3368 size = posix_acl_xattr_size(count);
790fe579 3369 if ((buflen == 0) || (local_acl == NULL)) {
50c2f753 3370 /* used to query ACL EA size */
790fe579 3371 } else if (size > buflen) {
1da177e4
LT		 3372 return -ERANGE;
3373 } else /* buffer big enough */ {
ff7feac9 3374 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
50c2f753
SF		 3375 for (i = 0; i < count ; i++) {
3376 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3377 pACE++;
1da177e4
LT		 3378 }
3379 }
3380 return size;
3381}
3382
50c2f753
SF		 3383static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3384 const posix_acl_xattr_entry *local_ace)
1da177e4
LT		 3385{
3386 __u16 rc = 0; /* 0 = ACL converted ok */
3387
ff7feac9
SF		 3388 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3389 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
1da177e4 3390 /* BB is there a better way to handle the large uid? */
790fe579 3391 if (local_ace->e_id == cpu_to_le32(-1)) {
1da177e4
LT		 3392 /* Probably no need to le convert -1 on any arch but can not hurt */
3393 cifs_ace->cifs_uid = cpu_to_le64(-1);
50c2f753 3394 } else
ff7feac9 3395 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
b6b38f70 3396 /*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
1da177e4
LT		 3397 return rc;
3398}
3399
3400/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
50c2f753
SF		 3401static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3402 const int buflen, const int acl_type)
1da177e4
LT		 3403{
3404 __u16 rc = 0;
50c2f753
SF		 3405 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3406 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
1da177e4
LT		 3407 int count;
3408 int i;
3409
790fe579 3410 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
1da177e4
LT		 3411 return 0;
3412
3413 count = posix_acl_xattr_count((size_t)buflen);
b6b38f70 3414 cFYI(1, "setting acl with %d entries from buf of length %d and "
63135e08 3415 "version of %d",
b6b38f70 3416 count, buflen, le32_to_cpu(local_acl->a_version));
790fe579 3417 if (le32_to_cpu(local_acl->a_version) != 2) {
b6b38f70
JP		 3418 cFYI(1, "unknown POSIX ACL version %d",
3419 le32_to_cpu(local_acl->a_version));
1da177e4
LT		 3420 return 0;
3421 }
3422 cifs_acl->version = cpu_to_le16(1);
790fe579 3423 if (acl_type == ACL_TYPE_ACCESS)
ff7feac9 3424 cifs_acl->access_entry_count = cpu_to_le16(count);
790fe579 3425 else if (acl_type == ACL_TYPE_DEFAULT)
ff7feac9 3426 cifs_acl->default_entry_count = cpu_to_le16(count);
1da177e4 3427 else {
b6b38f70 3428 cFYI(1, "unknown ACL type %d", acl_type);
1da177e4
LT		 3429 return 0;
3430 }
50c2f753 3431 for (i = 0; i < count; i++) {
1da177e4
LT		 3432 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3433 &local_acl->a_entries[i]);
790fe579 3434 if (rc != 0) {
1da177e4
LT		 3435 /* ACE not converted */
3436 break;
3437 }
3438 }
790fe579 3439 if (rc == 0) {
1da177e4
LT		 3440 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3441 rc += sizeof(struct cifs_posix_acl);
3442 /* BB add check to make sure ACL does not overflow SMB */
3443 }
3444 return rc;
3445}
3446
3447int
96daf2b0 3448CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
50c2f753
SF		 3449 const unsigned char *searchName,
3450 char *acl_inf, const int buflen, const int acl_type,
3451 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 3452{
3453/* SMB_QUERY_POSIX_ACL */
3454 TRANSACTION2_QPI_REQ *pSMB = NULL;
3455 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3456 int rc = 0;
3457 int bytes_returned;
3458 int name_len;
3459 __u16 params, byte_count;
50c2f753 3460
b6b38f70 3461 cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
1da177e4
LT		 3462
3463queryAclRetry:
3464 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3465 (void **) &pSMBr);
3466 if (rc)
3467 return rc;
50c2f753 3468
1da177e4
LT		 3469 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3470 name_len =
acbbb76a
SF		 3471 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3472 searchName, PATH_MAX, nls_codepage,
3473 remap);
1da177e4
LT		 3474 name_len++; /* trailing null */
3475 name_len *= 2;
3476 pSMB->FileName[name_len] = 0;
3477 pSMB->FileName[name_len+1] = 0;
50c2f753 3478 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 3479 name_len = strnlen(searchName, PATH_MAX);
3480 name_len++; /* trailing null */
3481 strncpy(pSMB->FileName, searchName, name_len);
3482 }
3483
3484 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3485 pSMB->TotalDataCount = 0;
3486 pSMB->MaxParameterCount = cpu_to_le16(2);
50c2f753 3487 /* BB find exact max data count below from sess structure BB */
1da177e4
LT		 3488 pSMB->MaxDataCount = cpu_to_le16(4000);
3489 pSMB->MaxSetupCount = 0;
3490 pSMB->Reserved = 0;
3491 pSMB->Flags = 0;
3492 pSMB->Timeout = 0;
3493 pSMB->Reserved2 = 0;
3494 pSMB->ParameterOffset = cpu_to_le16(
50c2f753
SF		 3495 offsetof(struct smb_com_transaction2_qpi_req,
3496 InformationLevel) - 4);
1da177e4
LT		 3497 pSMB->DataCount = 0;
3498 pSMB->DataOffset = 0;
3499 pSMB->SetupCount = 1;
3500 pSMB->Reserved3 = 0;
3501 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3502 byte_count = params + 1 /* pad */ ;
3503 pSMB->TotalParameterCount = cpu_to_le16(params);
3504 pSMB->ParameterCount = pSMB->TotalParameterCount;
3505 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3506 pSMB->Reserved4 = 0;
be8e3b00 3507 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 3508 pSMB->ByteCount = cpu_to_le16(byte_count);
3509
3510 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3511 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
0a4b92c0 3512 cifs_stats_inc(&tcon->num_acl_get);
1da177e4 3513 if (rc) {
b6b38f70 3514 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
1da177e4
LT		 3515 } else {
3516 /* decode response */
50c2f753 3517
1da177e4 3518 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1da177e4 3519 /* BB also check enough total bytes returned */
820a803f 3520 if (rc || get_bcc(&pSMBr->hdr) < 2)
1da177e4
LT		 3521 rc = -EIO; /* bad smb */
3522 else {
3523 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3524 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3525 rc = cifs_copy_posix_acl(acl_inf,
3526 (char *)&pSMBr->hdr.Protocol+data_offset,
50c2f753 3527 buflen, acl_type, count);
1da177e4
LT		 3528 }
3529 }
3530 cifs_buf_release(pSMB);
3531 if (rc == -EAGAIN)
3532 goto queryAclRetry;
3533 return rc;
3534}
3535
3536int
96daf2b0 3537CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
50c2f753
SF		 3538 const unsigned char *fileName,
3539 const char *local_acl, const int buflen,
3540 const int acl_type,
3541 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 3542{
3543 struct smb_com_transaction2_spi_req *pSMB = NULL;
3544 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3545 char *parm_data;
3546 int name_len;
3547 int rc = 0;
3548 int bytes_returned = 0;
3549 __u16 params, byte_count, data_count, param_offset, offset;
3550
b6b38f70 3551 cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
1da177e4
LT		 3552setAclRetry:
3553 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
50c2f753 3554 (void **) &pSMBr);
1da177e4
LT		 3555 if (rc)
3556 return rc;
3557 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3558 name_len =
acbbb76a
SF		 3559 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3560 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 3561 name_len++; /* trailing null */
3562 name_len *= 2;
50c2f753 3563 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 3564 name_len = strnlen(fileName, PATH_MAX);
3565 name_len++; /* trailing null */
3566 strncpy(pSMB->FileName, fileName, name_len);
3567 }
3568 params = 6 + name_len;
3569 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 3570 /* BB find max SMB size from sess */
3571 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 3572 pSMB->MaxSetupCount = 0;
3573 pSMB->Reserved = 0;
3574 pSMB->Flags = 0;
3575 pSMB->Timeout = 0;
3576 pSMB->Reserved2 = 0;
3577 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 3578 InformationLevel) - 4;
1da177e4
LT		 3579 offset = param_offset + params;
3580 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3581 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3582
3583 /* convert to on the wire format for POSIX ACL */
50c2f753 3584 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
1da177e4 3585
790fe579 3586 if (data_count == 0) {
1da177e4
LT		 3587 rc = -EOPNOTSUPP;
3588 goto setACLerrorExit;
3589 }
3590 pSMB->DataOffset = cpu_to_le16(offset);
3591 pSMB->SetupCount = 1;
3592 pSMB->Reserved3 = 0;
3593 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3594 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3595 byte_count = 3 /* pad */ + params + data_count;
3596 pSMB->DataCount = cpu_to_le16(data_count);
3597 pSMB->TotalDataCount = pSMB->DataCount;
3598 pSMB->ParameterCount = cpu_to_le16(params);
3599 pSMB->TotalParameterCount = pSMB->ParameterCount;
3600 pSMB->Reserved4 = 0;
be8e3b00 3601 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 3602 pSMB->ByteCount = cpu_to_le16(byte_count);
3603 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
50c2f753 3604 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 3605 if (rc)
b6b38f70 3606 cFYI(1, "Set POSIX ACL returned %d", rc);
1da177e4
LT		 3607
3608setACLerrorExit:
3609 cifs_buf_release(pSMB);
3610 if (rc == -EAGAIN)
3611 goto setAclRetry;
3612 return rc;
3613}
3614
f654bac2
SF		 3615/* BB fix tabs in this function FIXME BB */
3616int
96daf2b0 3617CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
ad7a2926 3618 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
f654bac2 3619{
50c2f753
SF		 3620 int rc = 0;
3621 struct smb_t2_qfi_req *pSMB = NULL;
3622 struct smb_t2_qfi_rsp *pSMBr = NULL;
3623 int bytes_returned;
3624 __u16 params, byte_count;
f654bac2 3625
b6b38f70 3626 cFYI(1, "In GetExtAttr");
790fe579
SF		 3627 if (tcon == NULL)
3628 return -ENODEV;
f654bac2
SF		 3629
3630GetExtAttrRetry:
790fe579
SF		 3631 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3632 (void **) &pSMBr);
3633 if (rc)
3634 return rc;
f654bac2 3635
ad7a2926 3636 params = 2 /* level */ + 2 /* fid */;
790fe579
SF		 3637 pSMB->t2.TotalDataCount = 0;
3638 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3639 /* BB find exact max data count below from sess structure BB */
3640 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3641 pSMB->t2.MaxSetupCount = 0;
3642 pSMB->t2.Reserved = 0;
3643 pSMB->t2.Flags = 0;
3644 pSMB->t2.Timeout = 0;
3645 pSMB->t2.Reserved2 = 0;
3646 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3647 Fid) - 4);
3648 pSMB->t2.DataCount = 0;
3649 pSMB->t2.DataOffset = 0;
3650 pSMB->t2.SetupCount = 1;
3651 pSMB->t2.Reserved3 = 0;
3652 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3653 byte_count = params + 1 /* pad */ ;
3654 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3655 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3656 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3657 pSMB->Pad = 0;
f654bac2 3658 pSMB->Fid = netfid;
be8e3b00 3659 inc_rfc1001_len(pSMB, byte_count);
790fe579
SF		 3660 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3661
3662 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3663 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3664 if (rc) {
b6b38f70 3665 cFYI(1, "error %d in GetExtAttr", rc);
790fe579
SF		 3666 } else {
3667 /* decode response */
3668 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
790fe579 3669 /* BB also check enough total bytes returned */
820a803f 3670 if (rc || get_bcc(&pSMBr->hdr) < 2)
790fe579
SF		 3671 /* If rc should we check for EOPNOSUPP and
3672 disable the srvino flag? or in caller? */
3673 rc = -EIO; /* bad smb */
3674 else {
3675 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3676 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3677 struct file_chattr_info *pfinfo;
3678 /* BB Do we need a cast or hash here ? */
3679 if (count != 16) {
b6b38f70 3680 cFYI(1, "Illegal size ret in GetExtAttr");
790fe579
SF		 3681 rc = -EIO;
3682 goto GetExtAttrOut;
3683 }
3684 pfinfo = (struct file_chattr_info *)
3685 (data_offset + (char *) &pSMBr->hdr.Protocol);
3686 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
f654bac2 3687 *pMask = le64_to_cpu(pfinfo->mask);
790fe579
SF		 3688 }
3689 }
f654bac2 3690GetExtAttrOut:
790fe579
SF		 3691 cifs_buf_release(pSMB);
3692 if (rc == -EAGAIN)
3693 goto GetExtAttrRetry;
3694 return rc;
f654bac2
SF		 3695}
3696
f654bac2 3697#endif /* CONFIG_POSIX */
1da177e4 3698
79df1bae
JL		 3699#ifdef CONFIG_CIFS_ACL
3700/*
3701 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3702 * all NT TRANSACTS that we init here have total parm and data under about 400
3703 * bytes (to fit in small cifs buffer size), which is the case so far, it
3704 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3705 * returned setup area) and MaxParameterCount (returned parms size) must be set
3706 * by caller
3707 */
3708static int
3709smb_init_nttransact(const __u16 sub_command, const int setup_count,
96daf2b0 3710 const int parm_len, struct cifs_tcon *tcon,
79df1bae
JL		 3711 void **ret_buf)
3712{
3713 int rc;
3714 __u32 temp_offset;
3715 struct smb_com_ntransact_req *pSMB;
3716
3717 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3718 (void **)&pSMB);
3719 if (rc)
3720 return rc;
3721 *ret_buf = (void *)pSMB;
3722 pSMB->Reserved = 0;
3723 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3724 pSMB->TotalDataCount = 0;
c974befa 3725 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
79df1bae
JL		 3726 pSMB->ParameterCount = pSMB->TotalParameterCount;
3727 pSMB->DataCount = pSMB->TotalDataCount;
3728 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3729 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3730 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3731 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3732 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3733 pSMB->SubCommand = cpu_to_le16(sub_command);
3734 return 0;
3735}
3736
3737static int
3738validate_ntransact(char *buf, char **ppparm, char **ppdata,
3739 __u32 *pparmlen, __u32 *pdatalen)
3740{
3741 char *end_of_smb;
3742 __u32 data_count, data_offset, parm_count, parm_offset;
3743 struct smb_com_ntransact_rsp *pSMBr;
820a803f 3744 u16 bcc;
79df1bae
JL		 3745
3746 *pdatalen = 0;
3747 *pparmlen = 0;
3748
3749 if (buf == NULL)
3750 return -EINVAL;
3751
3752 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3753
820a803f
JL		 3754 bcc = get_bcc(&pSMBr->hdr);
3755 end_of_smb = 2 /* sizeof byte count */ + bcc +
79df1bae
JL		 3756 (char *)&pSMBr->ByteCount;
3757
3758 data_offset = le32_to_cpu(pSMBr->DataOffset);
3759 data_count = le32_to_cpu(pSMBr->DataCount);
3760 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3761 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3762
3763 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3764 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3765
3766 /* should we also check that parm and data areas do not overlap? */
3767 if (*ppparm > end_of_smb) {
3768 cFYI(1, "parms start after end of smb");
3769 return -EINVAL;
3770 } else if (parm_count + *ppparm > end_of_smb) {
3771 cFYI(1, "parm end after end of smb");
3772 return -EINVAL;
3773 } else if (*ppdata > end_of_smb) {
3774 cFYI(1, "data starts after end of smb");
3775 return -EINVAL;
3776 } else if (data_count + *ppdata > end_of_smb) {
3777 cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
3778 *ppdata, data_count, (data_count + *ppdata),
3779 end_of_smb, pSMBr);
3780 return -EINVAL;
820a803f 3781 } else if (parm_count + data_count > bcc) {
79df1bae
JL		 3782 cFYI(1, "parm count and data count larger than SMB");
3783 return -EINVAL;
3784 }
3785 *pdatalen = data_count;
3786 *pparmlen = parm_count;
3787 return 0;
3788}
3789
0a4b92c0
SF		 3790/* Get Security Descriptor (by handle) from remote server for a file or dir */
3791int
96daf2b0 3792CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
630f3f0c 3793 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
0a4b92c0
SF		 3794{
3795 int rc = 0;
3796 int buf_type = 0;
ad7a2926 3797 QUERY_SEC_DESC_REQ *pSMB;
0a4b92c0
SF		 3798 struct kvec iov[1];
3799
b6b38f70 3800 cFYI(1, "GetCifsACL");
0a4b92c0 3801
630f3f0c
SF		 3802 *pbuflen = 0;
3803 *acl_inf = NULL;
3804
b9c7a2bb 3805 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
0a4b92c0
SF		 3806 8 /* parm len */, tcon, (void **) &pSMB);
3807 if (rc)
3808 return rc;
3809
3810 pSMB->MaxParameterCount = cpu_to_le32(4);
3811 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3812 pSMB->MaxSetupCount = 0;
3813 pSMB->Fid = fid; /* file handle always le */
3814 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3815 CIFS_ACL_DACL);
3816 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
be8e3b00 3817 inc_rfc1001_len(pSMB, 11);
0a4b92c0 3818 iov[0].iov_base = (char *)pSMB;
be8e3b00 3819 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
0a4b92c0 3820
a761ac57 3821 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
7749981e 3822 0);
0a4b92c0
SF		 3823 cifs_stats_inc(&tcon->num_acl_get);
3824 if (rc) {
b6b38f70 3825 cFYI(1, "Send error in QuerySecDesc = %d", rc);
0a4b92c0 3826 } else { /* decode response */
ad7a2926 3827 __le32 *parm;
630f3f0c
SF		 3828 __u32 parm_len;
3829 __u32 acl_len;
50c2f753 3830 struct smb_com_ntransact_rsp *pSMBr;
630f3f0c 3831 char *pdata;
0a4b92c0
SF		 3832
3833/* validate_nttransact */
50c2f753 3834 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
630f3f0c 3835 &pdata, &parm_len, pbuflen);
790fe579 3836 if (rc)
0a4b92c0
SF		 3837 goto qsec_out;
3838 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3839
b6b38f70 3840 cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
0a4b92c0
SF		 3841
3842 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3843 rc = -EIO; /* bad smb */
630f3f0c 3844 *pbuflen = 0;
0a4b92c0
SF		 3845 goto qsec_out;
3846 }
3847
3848/* BB check that data area is minimum length and as big as acl_len */
3849
af6f4612 3850 acl_len = le32_to_cpu(*parm);
630f3f0c 3851 if (acl_len != *pbuflen) {
b6b38f70
JP		 3852 cERROR(1, "acl length %d does not match %d",
3853 acl_len, *pbuflen);
630f3f0c
SF		 3854 if (*pbuflen > acl_len)
3855 *pbuflen = acl_len;
3856 }
0a4b92c0 3857
630f3f0c
SF		 3858 /* check if buffer is big enough for the acl
3859 header followed by the smallest SID */
3860 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3861 (*pbuflen >= 64 * 1024)) {
b6b38f70 3862 cERROR(1, "bad acl length %d", *pbuflen);
630f3f0c
SF		 3863 rc = -EINVAL;
3864 *pbuflen = 0;
3865 } else {
3866 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3867 if (*acl_inf == NULL) {
3868 *pbuflen = 0;
3869 rc = -ENOMEM;
3870 }
3871 memcpy(*acl_inf, pdata, *pbuflen);
3872 }
0a4b92c0
SF		 3873 }
3874qsec_out:
790fe579 3875 if (buf_type == CIFS_SMALL_BUFFER)
0a4b92c0 3876 cifs_small_buf_release(iov[0].iov_base);
790fe579 3877 else if (buf_type == CIFS_LARGE_BUFFER)
0a4b92c0 3878 cifs_buf_release(iov[0].iov_base);
4b8f930f 3879/* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
0a4b92c0
SF		 3880 return rc;
3881}
97837582
SF		 3882
3883int
96daf2b0 3884CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
a5ff3769 3885 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
97837582
SF		 3886{
3887 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3888 int rc = 0;
3889 int bytes_returned = 0;
3890 SET_SEC_DESC_REQ *pSMB = NULL;
3891 NTRANSACT_RSP *pSMBr = NULL;
3892
3893setCifsAclRetry:
3894 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3895 (void **) &pSMBr);
3896 if (rc)
3897 return (rc);
3898
3899 pSMB->MaxSetupCount = 0;
3900 pSMB->Reserved = 0;
3901
3902 param_count = 8;
3903 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3904 data_count = acllen;
3905 data_offset = param_offset + param_count;
3906 byte_count = 3 /* pad */ + param_count;
3907
3908 pSMB->DataCount = cpu_to_le32(data_count);
3909 pSMB->TotalDataCount = pSMB->DataCount;
3910 pSMB->MaxParameterCount = cpu_to_le32(4);
3911 pSMB->MaxDataCount = cpu_to_le32(16384);
3912 pSMB->ParameterCount = cpu_to_le32(param_count);
3913 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3914 pSMB->TotalParameterCount = pSMB->ParameterCount;
3915 pSMB->DataOffset = cpu_to_le32(data_offset);
3916 pSMB->SetupCount = 0;
3917 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3918 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3919
3920 pSMB->Fid = fid; /* file handle always le */
3921 pSMB->Reserved2 = 0;
a5ff3769 3922 pSMB->AclFlags = cpu_to_le32(aclflag);
97837582
SF		 3923
3924 if (pntsd && acllen) {
3925 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3926 (char *) pntsd,
3927 acllen);
be8e3b00 3928 inc_rfc1001_len(pSMB, byte_count + data_count);
97837582 3929 } else
be8e3b00 3930 inc_rfc1001_len(pSMB, byte_count);
97837582
SF		 3931
3932 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3933 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3934
b6b38f70 3935 cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
97837582 3936 if (rc)
b6b38f70 3937 cFYI(1, "Set CIFS ACL returned %d", rc);
97837582
SF		 3938 cifs_buf_release(pSMB);
3939
3940 if (rc == -EAGAIN)
3941 goto setCifsAclRetry;
3942
3943 return (rc);
3944}
3945
79df1bae 3946#endif /* CONFIG_CIFS_ACL */
0a4b92c0 3947
6b8edfe0
SF		 3948/* Legacy Query Path Information call for lookup to old servers such
3949 as Win9x/WinME */
96daf2b0 3950int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
50c2f753
SF		 3951 const unsigned char *searchName,
3952 FILE_ALL_INFO *pFinfo,
3953 const struct nls_table *nls_codepage, int remap)
6b8edfe0 3954{
ad7a2926
SF		 3955 QUERY_INFORMATION_REQ *pSMB;
3956 QUERY_INFORMATION_RSP *pSMBr;
6b8edfe0
SF		 3957 int rc = 0;
3958 int bytes_returned;
3959 int name_len;
3960
b6b38f70 3961 cFYI(1, "In SMBQPath path %s", searchName);
6b8edfe0
SF		 3962QInfRetry:
3963 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
50c2f753 3964 (void **) &pSMBr);
6b8edfe0
SF		 3965 if (rc)
3966 return rc;
3967
3968 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3969 name_len =
acbbb76a
SF		 3970 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3971 searchName, PATH_MAX, nls_codepage,
3972 remap);
6b8edfe0
SF		 3973 name_len++; /* trailing null */
3974 name_len *= 2;
50c2f753 3975 } else {
6b8edfe0
SF		 3976 name_len = strnlen(searchName, PATH_MAX);
3977 name_len++; /* trailing null */
3978 strncpy(pSMB->FileName, searchName, name_len);
3979 }
3980 pSMB->BufferFormat = 0x04;
50c2f753 3981 name_len++; /* account for buffer type byte */
be8e3b00 3982 inc_rfc1001_len(pSMB, (__u16)name_len);
6b8edfe0
SF		 3983 pSMB->ByteCount = cpu_to_le16(name_len);
3984
3985 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
50c2f753 3986 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6b8edfe0 3987 if (rc) {
b6b38f70 3988 cFYI(1, "Send error in QueryInfo = %d", rc);
ad7a2926 3989 } else if (pFinfo) {
1bd5bbcb
SF		 3990 struct timespec ts;
3991 __u32 time = le32_to_cpu(pSMBr->last_write_time);
ad7a2926
SF		 3992
3993 /* decode response */
1bd5bbcb 3994 /* BB FIXME - add time zone adjustment BB */
6b8edfe0 3995 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
1bd5bbcb
SF		 3996 ts.tv_nsec = 0;
3997 ts.tv_sec = time;
3998 /* decode time fields */
733f99ac 3999 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
1bd5bbcb
SF		 4000 pFinfo->LastWriteTime = pFinfo->ChangeTime;
4001 pFinfo->LastAccessTime = 0;
70ca734a
SF		 4002 pFinfo->AllocationSize =
4003 cpu_to_le64(le32_to_cpu(pSMBr->size));
4004 pFinfo->EndOfFile = pFinfo->AllocationSize;
4005 pFinfo->Attributes =
4006 cpu_to_le32(le16_to_cpu(pSMBr->attr));
6b8edfe0
SF		 4007 } else
4008 rc = -EIO; /* bad buffer passed in */
4009
4010 cifs_buf_release(pSMB);
4011
4012 if (rc == -EAGAIN)
4013 goto QInfRetry;
4014
4015 return rc;
4016}
4017
bcd5357f 4018int
96daf2b0 4019CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
bcd5357f
JL		 4020 u16 netfid, FILE_ALL_INFO *pFindData)
4021{
4022 struct smb_t2_qfi_req *pSMB = NULL;
4023 struct smb_t2_qfi_rsp *pSMBr = NULL;
4024 int rc = 0;
4025 int bytes_returned;
4026 __u16 params, byte_count;
4027
4028QFileInfoRetry:
4029 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4030 (void **) &pSMBr);
4031 if (rc)
4032 return rc;
4033
4034 params = 2 /* level */ + 2 /* fid */;
4035 pSMB->t2.TotalDataCount = 0;
4036 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4037 /* BB find exact max data count below from sess structure BB */
4038 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4039 pSMB->t2.MaxSetupCount = 0;
4040 pSMB->t2.Reserved = 0;
4041 pSMB->t2.Flags = 0;
4042 pSMB->t2.Timeout = 0;
4043 pSMB->t2.Reserved2 = 0;
4044 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4045 Fid) - 4);
4046 pSMB->t2.DataCount = 0;
4047 pSMB->t2.DataOffset = 0;
4048 pSMB->t2.SetupCount = 1;
4049 pSMB->t2.Reserved3 = 0;
4050 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4051 byte_count = params + 1 /* pad */ ;
4052 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4053 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4054 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4055 pSMB->Pad = 0;
4056 pSMB->Fid = netfid;
be8e3b00 4057 inc_rfc1001_len(pSMB, byte_count);
6b8edfe0 4058
bcd5357f
JL		 4059 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4060 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4061 if (rc) {
f19159dc 4062 cFYI(1, "Send error in QPathInfo = %d", rc);
bcd5357f
JL		 4063 } else { /* decode response */
4064 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6b8edfe0 4065
bcd5357f
JL		 4066 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4067 rc = -EIO;
820a803f 4068 else if (get_bcc(&pSMBr->hdr) < 40)
bcd5357f
JL		 4069 rc = -EIO; /* bad smb */
4070 else if (pFindData) {
4071 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4072 memcpy((char *) pFindData,
4073 (char *) &pSMBr->hdr.Protocol +
4074 data_offset, sizeof(FILE_ALL_INFO));
4075 } else
4076 rc = -ENOMEM;
4077 }
4078 cifs_buf_release(pSMB);
4079 if (rc == -EAGAIN)
4080 goto QFileInfoRetry;
6b8edfe0 4081
bcd5357f
JL		 4082 return rc;
4083}
6b8edfe0 4084
1da177e4 4085int
96daf2b0 4086CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
1da177e4 4087 const unsigned char *searchName,
ad7a2926 4088 FILE_ALL_INFO *pFindData,
acf1a1b1 4089 int legacy /* old style infolevel */,
737b758c 4090 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 4091{
4092/* level 263 SMB_QUERY_FILE_ALL_INFO */
4093 TRANSACTION2_QPI_REQ *pSMB = NULL;
4094 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4095 int rc = 0;
4096 int bytes_returned;
4097 int name_len;
4098 __u16 params, byte_count;
4099
b6b38f70 4100/* cFYI(1, "In QPathInfo path %s", searchName); */
1da177e4
LT		 4101QPathInfoRetry:
4102 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4103 (void **) &pSMBr);
4104 if (rc)
4105 return rc;
4106
4107 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4108 name_len =
acbbb76a
SF		 4109 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4110 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 4111 name_len++; /* trailing null */
4112 name_len *= 2;
50c2f753 4113 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 4114 name_len = strnlen(searchName, PATH_MAX);
4115 name_len++; /* trailing null */
4116 strncpy(pSMB->FileName, searchName, name_len);
4117 }
4118
50c2f753 4119 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
1da177e4
LT		 4120 pSMB->TotalDataCount = 0;
4121 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 4122 /* BB find exact max SMB PDU from sess structure BB */
4123 pSMB->MaxDataCount = cpu_to_le16(4000);
1da177e4
LT		 4124 pSMB->MaxSetupCount = 0;
4125 pSMB->Reserved = 0;
4126 pSMB->Flags = 0;
4127 pSMB->Timeout = 0;
4128 pSMB->Reserved2 = 0;
4129 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 4130 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
1da177e4
LT		 4131 pSMB->DataCount = 0;
4132 pSMB->DataOffset = 0;
4133 pSMB->SetupCount = 1;
4134 pSMB->Reserved3 = 0;
4135 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4136 byte_count = params + 1 /* pad */ ;
4137 pSMB->TotalParameterCount = cpu_to_le16(params);
4138 pSMB->ParameterCount = pSMB->TotalParameterCount;
790fe579 4139 if (legacy)
acf1a1b1
SF		 4140 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4141 else
4142 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
1da177e4 4143 pSMB->Reserved4 = 0;
be8e3b00 4144 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 4145 pSMB->ByteCount = cpu_to_le16(byte_count);
4146
4147 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4148 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4149 if (rc) {
b6b38f70 4150 cFYI(1, "Send error in QPathInfo = %d", rc);
1da177e4
LT		 4151 } else { /* decode response */
4152 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4153
acf1a1b1
SF		 4154 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4155 rc = -EIO;
820a803f 4156 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
1da177e4 4157 rc = -EIO; /* bad smb */
820a803f 4158 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
50c2f753
SF		 4159 rc = -EIO; /* 24 or 26 expected but we do not read
4160 last field */
4161 else if (pFindData) {
acf1a1b1 4162 int size;
1da177e4 4163 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
ad7a2926
SF		 4164
4165 /* On legacy responses we do not read the last field,
4166 EAsize, fortunately since it varies by subdialect and
4167 also note it differs on Set vs. Get, ie two bytes or 4
4168 bytes depending but we don't care here */
4169 if (legacy)
acf1a1b1
SF		 4170 size = sizeof(FILE_INFO_STANDARD);
4171 else
4172 size = sizeof(FILE_ALL_INFO);
1da177e4
LT		 4173 memcpy((char *) pFindData,
4174 (char *) &pSMBr->hdr.Protocol +
acf1a1b1 4175 data_offset, size);
1da177e4
LT		 4176 } else
4177 rc = -ENOMEM;
4178 }
4179 cifs_buf_release(pSMB);
4180 if (rc == -EAGAIN)
4181 goto QPathInfoRetry;
4182
4183 return rc;
4184}
4185
c8634fd3 4186int
96daf2b0 4187CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
c8634fd3
JL		 4188 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4189{
4190 struct smb_t2_qfi_req *pSMB = NULL;
4191 struct smb_t2_qfi_rsp *pSMBr = NULL;
4192 int rc = 0;
4193 int bytes_returned;
4194 __u16 params, byte_count;
4195
4196UnixQFileInfoRetry:
4197 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4198 (void **) &pSMBr);
4199 if (rc)
4200 return rc;
4201
4202 params = 2 /* level */ + 2 /* fid */;
4203 pSMB->t2.TotalDataCount = 0;
4204 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4205 /* BB find exact max data count below from sess structure BB */
4206 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4207 pSMB->t2.MaxSetupCount = 0;
4208 pSMB->t2.Reserved = 0;
4209 pSMB->t2.Flags = 0;
4210 pSMB->t2.Timeout = 0;
4211 pSMB->t2.Reserved2 = 0;
4212 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4213 Fid) - 4);
4214 pSMB->t2.DataCount = 0;
4215 pSMB->t2.DataOffset = 0;
4216 pSMB->t2.SetupCount = 1;
4217 pSMB->t2.Reserved3 = 0;
4218 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4219 byte_count = params + 1 /* pad */ ;
4220 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4221 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4222 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4223 pSMB->Pad = 0;
4224 pSMB->Fid = netfid;
be8e3b00 4225 inc_rfc1001_len(pSMB, byte_count);
c8634fd3
JL		 4226
4227 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4228 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4229 if (rc) {
f19159dc 4230 cFYI(1, "Send error in QPathInfo = %d", rc);
c8634fd3
JL		 4231 } else { /* decode response */
4232 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4233
820a803f 4234 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
f19159dc 4235 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
c8634fd3 4236 "Unix Extensions can be disabled on mount "
f19159dc 4237 "by specifying the nosfu mount option.");
c8634fd3
JL		 4238 rc = -EIO; /* bad smb */
4239 } else {
4240 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4241 memcpy((char *) pFindData,
4242 (char *) &pSMBr->hdr.Protocol +
4243 data_offset,
4244 sizeof(FILE_UNIX_BASIC_INFO));
4245 }
4246 }
4247
4248 cifs_buf_release(pSMB);
4249 if (rc == -EAGAIN)
4250 goto UnixQFileInfoRetry;
4251
4252 return rc;
4253}
4254
1da177e4 4255int
96daf2b0 4256CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
1da177e4 4257 const unsigned char *searchName,
582d21e5 4258 FILE_UNIX_BASIC_INFO *pFindData,
737b758c 4259 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 4260{
4261/* SMB_QUERY_FILE_UNIX_BASIC */
4262 TRANSACTION2_QPI_REQ *pSMB = NULL;
4263 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4264 int rc = 0;
4265 int bytes_returned = 0;
4266 int name_len;
4267 __u16 params, byte_count;
4268
b6b38f70 4269 cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
1da177e4
LT		 4270UnixQPathInfoRetry:
4271 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4272 (void **) &pSMBr);
4273 if (rc)
4274 return rc;
4275
4276 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4277 name_len =
acbbb76a
SF		 4278 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4279 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 4280 name_len++; /* trailing null */
4281 name_len *= 2;
50c2f753 4282 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 4283 name_len = strnlen(searchName, PATH_MAX);
4284 name_len++; /* trailing null */
4285 strncpy(pSMB->FileName, searchName, name_len);
4286 }
4287
50c2f753 4288 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
1da177e4
LT		 4289 pSMB->TotalDataCount = 0;
4290 pSMB->MaxParameterCount = cpu_to_le16(2);
4291 /* BB find exact max SMB PDU from sess structure BB */
50c2f753 4292 pSMB->MaxDataCount = cpu_to_le16(4000);
1da177e4
LT		 4293 pSMB->MaxSetupCount = 0;
4294 pSMB->Reserved = 0;
4295 pSMB->Flags = 0;
4296 pSMB->Timeout = 0;
4297 pSMB->Reserved2 = 0;
4298 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 4299 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
1da177e4
LT		 4300 pSMB->DataCount = 0;
4301 pSMB->DataOffset = 0;
4302 pSMB->SetupCount = 1;
4303 pSMB->Reserved3 = 0;
4304 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4305 byte_count = params + 1 /* pad */ ;
4306 pSMB->TotalParameterCount = cpu_to_le16(params);
4307 pSMB->ParameterCount = pSMB->TotalParameterCount;
4308 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4309 pSMB->Reserved4 = 0;
be8e3b00 4310 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 4311 pSMB->ByteCount = cpu_to_le16(byte_count);
4312
4313 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4314 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4315 if (rc) {
b6b38f70 4316 cFYI(1, "Send error in QPathInfo = %d", rc);
1da177e4
LT		 4317 } else { /* decode response */
4318 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4319
820a803f 4320 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
b6b38f70 4321 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
1e71f25d 4322 "Unix Extensions can be disabled on mount "
b6b38f70 4323 "by specifying the nosfu mount option.");
1da177e4
LT		 4324 rc = -EIO; /* bad smb */
4325 } else {
4326 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4327 memcpy((char *) pFindData,
4328 (char *) &pSMBr->hdr.Protocol +
4329 data_offset,
630f3f0c 4330 sizeof(FILE_UNIX_BASIC_INFO));
1da177e4
LT		 4331 }
4332 }
4333 cifs_buf_release(pSMB);
4334 if (rc == -EAGAIN)
4335 goto UnixQPathInfoRetry;
4336
4337 return rc;
4338}
4339
1da177e4
LT		 4340/* xid, tcon, searchName and codepage are input parms, rest are returned */
4341int
96daf2b0 4342CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
50c2f753 4343 const char *searchName,
1da177e4 4344 const struct nls_table *nls_codepage,
50c2f753
SF		 4345 __u16 *pnetfid,
4346 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
1da177e4
LT		 4347{
4348/* level 257 SMB_ */
4349 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4350 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
ad7a2926 4351 T2_FFIRST_RSP_PARMS *parms;
1da177e4
LT		 4352 int rc = 0;
4353 int bytes_returned = 0;
4354 int name_len;
4355 __u16 params, byte_count;
4356
b6b38f70 4357 cFYI(1, "In FindFirst for %s", searchName);
1da177e4
LT		 4358
4359findFirstRetry:
4360 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4361 (void **) &pSMBr);
4362 if (rc)
4363 return rc;
4364
4365 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4366 name_len =
acbbb76a
SF		 4367 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4368 PATH_MAX, nls_codepage, remap);
737b758c
SF		 4369 /* We can not add the asterik earlier in case
4370 it got remapped to 0xF03A as if it were part of the
4371 directory name instead of a wildcard */
1da177e4 4372 name_len *= 2;
ac67055e 4373 pSMB->FileName[name_len] = dirsep;
737b758c
SF		 4374 pSMB->FileName[name_len+1] = 0;
4375 pSMB->FileName[name_len+2] = '*';
4376 pSMB->FileName[name_len+3] = 0;
4377 name_len += 4; /* now the trailing null */
1da177e4
LT		 4378 pSMB->FileName[name_len] = 0; /* null terminate just in case */
4379 pSMB->FileName[name_len+1] = 0;
737b758c 4380 name_len += 2;
1da177e4
LT		 4381 } else { /* BB add check for overrun of SMB buf BB */
4382 name_len = strnlen(searchName, PATH_MAX);
1da177e4 4383/* BB fix here and in unicode clause above ie
790fe579 4384 if (name_len > buffersize-header)
1da177e4
LT		 4385 free buffer exit; BB */
4386 strncpy(pSMB->FileName, searchName, name_len);
ac67055e 4387 pSMB->FileName[name_len] = dirsep;
68575476
SF		 4388 pSMB->FileName[name_len+1] = '*';
4389 pSMB->FileName[name_len+2] = 0;
4390 name_len += 3;
1da177e4
LT		 4391 }
4392
4393 params = 12 + name_len /* includes null */ ;
4394 pSMB->TotalDataCount = 0; /* no EAs */
4395 pSMB->MaxParameterCount = cpu_to_le16(10);
c974befa 4396 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
1da177e4
LT		 4397 pSMB->MaxSetupCount = 0;
4398 pSMB->Reserved = 0;
4399 pSMB->Flags = 0;
4400 pSMB->Timeout = 0;
4401 pSMB->Reserved2 = 0;
4402 byte_count = params + 1 /* pad */ ;
4403 pSMB->TotalParameterCount = cpu_to_le16(params);
4404 pSMB->ParameterCount = pSMB->TotalParameterCount;
4405 pSMB->ParameterOffset = cpu_to_le16(
88274815
SF		 4406 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4407 - 4);
1da177e4
LT		 4408 pSMB->DataCount = 0;
4409 pSMB->DataOffset = 0;
4410 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4411 pSMB->Reserved3 = 0;
4412 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4413 pSMB->SearchAttributes =
4414 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4415 ATTR_DIRECTORY);
50c2f753
SF		 4416 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4417 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
1da177e4
LT		 4418 CIFS_SEARCH_RETURN_RESUME);
4419 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4420
4421 /* BB what should we set StorageType to? Does it matter? BB */
4422 pSMB->SearchStorageType = 0;
be8e3b00 4423 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 4424 pSMB->ByteCount = cpu_to_le16(byte_count);
4425
4426 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4427 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 4428 cifs_stats_inc(&tcon->num_ffirst);
1da177e4 4429
88274815
SF		 4430 if (rc) {/* BB add logic to retry regular search if Unix search
4431 rejected unexpectedly by server */
1da177e4 4432 /* BB Add code to handle unsupported level rc */
b6b38f70 4433 cFYI(1, "Error in FindFirst = %d", rc);
1982c344 4434
88274815 4435 cifs_buf_release(pSMB);
1da177e4
LT		 4436
4437 /* BB eventually could optimize out free and realloc of buf */
4438 /* for this case */
4439 if (rc == -EAGAIN)
4440 goto findFirstRetry;
4441 } else { /* decode response */
4442 /* BB remember to free buffer if error BB */
4443 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
790fe579 4444 if (rc == 0) {
b77d753c
SF		 4445 unsigned int lnoff;
4446
1da177e4 4447 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4b18f2a9 4448 psrch_inf->unicode = true;
1da177e4 4449 else
4b18f2a9 4450 psrch_inf->unicode = false;
1da177e4
LT		 4451
4452 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
d47d7c1a 4453 psrch_inf->smallBuf = 0;
50c2f753
SF		 4454 psrch_inf->srch_entries_start =
4455 (char *) &pSMBr->hdr.Protocol +
1da177e4 4456 le16_to_cpu(pSMBr->t2.DataOffset);
1da177e4
LT		 4457 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4458 le16_to_cpu(pSMBr->t2.ParameterOffset));
4459
790fe579 4460 if (parms->EndofSearch)
4b18f2a9 4461 psrch_inf->endOfSearch = true;
1da177e4 4462 else
4b18f2a9 4463 psrch_inf->endOfSearch = false;
1da177e4 4464
50c2f753
SF		 4465 psrch_inf->entries_in_buffer =
4466 le16_to_cpu(parms->SearchCount);
60808233 4467 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
1da177e4 4468 psrch_inf->entries_in_buffer;
b77d753c 4469 lnoff = le16_to_cpu(parms->LastNameOffset);
c974befa 4470 if (CIFSMaxBufSize < lnoff) {
b6b38f70 4471 cERROR(1, "ignoring corrupt resume name");
b77d753c
SF		 4472 psrch_inf->last_entry = NULL;
4473 return rc;
4474 }
4475
0752f152 4476 psrch_inf->last_entry = psrch_inf->srch_entries_start +
b77d753c
SF		 4477 lnoff;
4478
1da177e4
LT		 4479 *pnetfid = parms->SearchHandle;
4480 } else {
4481 cifs_buf_release(pSMB);
4482 }
4483 }
4484
4485 return rc;
4486}
4487
96daf2b0 4488int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
50c2f753 4489 __u16 searchHandle, struct cifs_search_info *psrch_inf)
1da177e4
LT		 4490{
4491 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4492 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
ad7a2926 4493 T2_FNEXT_RSP_PARMS *parms;
1da177e4
LT		 4494 char *response_data;
4495 int rc = 0;
9438fabb
JL		 4496 int bytes_returned;
4497 unsigned int name_len;
1da177e4
LT		 4498 __u16 params, byte_count;
4499
b6b38f70 4500 cFYI(1, "In FindNext");
1da177e4 4501
4b18f2a9 4502 if (psrch_inf->endOfSearch)
1da177e4
LT		 4503 return -ENOENT;
4504
4505 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4506 (void **) &pSMBr);
4507 if (rc)
4508 return rc;
4509
50c2f753 4510 params = 14; /* includes 2 bytes of null string, converted to LE below*/
1da177e4
LT		 4511 byte_count = 0;
4512 pSMB->TotalDataCount = 0; /* no EAs */
4513 pSMB->MaxParameterCount = cpu_to_le16(8);
c974befa 4514 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
1da177e4
LT		 4515 pSMB->MaxSetupCount = 0;
4516 pSMB->Reserved = 0;
4517 pSMB->Flags = 0;
4518 pSMB->Timeout = 0;
4519 pSMB->Reserved2 = 0;
4520 pSMB->ParameterOffset = cpu_to_le16(
4521 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4522 pSMB->DataCount = 0;
4523 pSMB->DataOffset = 0;
4524 pSMB->SetupCount = 1;
4525 pSMB->Reserved3 = 0;
4526 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4527 pSMB->SearchHandle = searchHandle; /* always kept as le */
4528 pSMB->SearchCount =
630f3f0c 4529 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
1da177e4
LT		 4530 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4531 pSMB->ResumeKey = psrch_inf->resume_key;
4532 pSMB->SearchFlags =
4533 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
4534
4535 name_len = psrch_inf->resume_name_len;
4536 params += name_len;
790fe579 4537 if (name_len < PATH_MAX) {
1da177e4
LT		 4538 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4539 byte_count += name_len;
ef6724e3
SF		 4540 /* 14 byte parm len above enough for 2 byte null terminator */
4541 pSMB->ResumeFileName[name_len] = 0;
4542 pSMB->ResumeFileName[name_len+1] = 0;
1da177e4
LT		 4543 } else {
4544 rc = -EINVAL;
4545 goto FNext2_err_exit;
4546 }
4547 byte_count = params + 1 /* pad */ ;
4548 pSMB->TotalParameterCount = cpu_to_le16(params);
4549 pSMB->ParameterCount = pSMB->TotalParameterCount;
be8e3b00 4550 inc_rfc1001_len(pSMB, byte_count);
1da177e4 4551 pSMB->ByteCount = cpu_to_le16(byte_count);
50c2f753 4552
1da177e4
LT		 4553 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4554 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
a4544347 4555 cifs_stats_inc(&tcon->num_fnext);
1da177e4
LT		 4556 if (rc) {
4557 if (rc == -EBADF) {
4b18f2a9 4558 psrch_inf->endOfSearch = true;
6353450a 4559 cifs_buf_release(pSMB);
50c2f753 4560 rc = 0; /* search probably was closed at end of search*/
1da177e4 4561 } else
b6b38f70 4562 cFYI(1, "FindNext returned = %d", rc);
1da177e4
LT		 4563 } else { /* decode response */
4564 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
50c2f753 4565
790fe579 4566 if (rc == 0) {
b77d753c
SF		 4567 unsigned int lnoff;
4568
1da177e4
LT		 4569 /* BB fixme add lock for file (srch_info) struct here */
4570 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4b18f2a9 4571 psrch_inf->unicode = true;
1da177e4 4572 else
4b18f2a9 4573 psrch_inf->unicode = false;
1da177e4
LT		 4574 response_data = (char *) &pSMBr->hdr.Protocol +
4575 le16_to_cpu(pSMBr->t2.ParameterOffset);
4576 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4577 response_data = (char *)&pSMBr->hdr.Protocol +
4578 le16_to_cpu(pSMBr->t2.DataOffset);
790fe579 4579 if (psrch_inf->smallBuf)
d47d7c1a
SF		 4580 cifs_small_buf_release(
4581 psrch_inf->ntwrk_buf_start);
4582 else
4583 cifs_buf_release(psrch_inf->ntwrk_buf_start);
1da177e4
LT		 4584 psrch_inf->srch_entries_start = response_data;
4585 psrch_inf->ntwrk_buf_start = (char *)pSMB;
d47d7c1a 4586 psrch_inf->smallBuf = 0;
790fe579 4587 if (parms->EndofSearch)
4b18f2a9 4588 psrch_inf->endOfSearch = true;
1da177e4 4589 else
4b18f2a9 4590 psrch_inf->endOfSearch = false;
50c2f753
SF		 4591 psrch_inf->entries_in_buffer =
4592 le16_to_cpu(parms->SearchCount);
1da177e4
LT		 4593 psrch_inf->index_of_last_entry +=
4594 psrch_inf->entries_in_buffer;
b77d753c 4595 lnoff = le16_to_cpu(parms->LastNameOffset);
c974befa 4596 if (CIFSMaxBufSize < lnoff) {
b6b38f70 4597 cERROR(1, "ignoring corrupt resume name");
b77d753c
SF		 4598 psrch_inf->last_entry = NULL;
4599 return rc;
4600 } else
4601 psrch_inf->last_entry =
4602 psrch_inf->srch_entries_start + lnoff;
4603
b6b38f70
JP		 4604/* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
4605 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
1da177e4
LT		 4606
4607 /* BB fixme add unlock here */
4608 }
4609
4610 }
4611
4612 /* BB On error, should we leave previous search buf (and count and
4613 last entry fields) intact or free the previous one? */
4614
4615 /* Note: On -EAGAIN error only caller can retry on handle based calls
4616 since file handle passed in no longer valid */
4617FNext2_err_exit:
4618 if (rc != 0)
4619 cifs_buf_release(pSMB);
1da177e4
LT		 4620 return rc;
4621}
4622
4623int
96daf2b0 4624CIFSFindClose(const int xid, struct cifs_tcon *tcon,
50c2f753 4625 const __u16 searchHandle)
1da177e4
LT		 4626{
4627 int rc = 0;
4628 FINDCLOSE_REQ *pSMB = NULL;
1da177e4 4629
b6b38f70 4630 cFYI(1, "In CIFSSMBFindClose");
1da177e4
LT		 4631 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4632
4633 /* no sense returning error if session restarted
4634 as file handle has been closed */
790fe579 4635 if (rc == -EAGAIN)
1da177e4
LT		 4636 return 0;
4637 if (rc)
4638 return rc;
4639
1da177e4
LT		 4640 pSMB->FileID = searchHandle;
4641 pSMB->ByteCount = 0;
792af7b0 4642 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
ad7a2926 4643 if (rc)
b6b38f70 4644 cERROR(1, "Send error in FindClose = %d", rc);
ad7a2926 4645
a4544347 4646 cifs_stats_inc(&tcon->num_fclose);
1da177e4
LT		 4647
4648 /* Since session is dead, search handle closed on server already */
4649 if (rc == -EAGAIN)
4650 rc = 0;
4651
4652 return rc;
4653}
4654
1da177e4 4655int
96daf2b0 4656CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
50c2f753 4657 const unsigned char *searchName,
ad7a2926 4658 __u64 *inode_number,
50c2f753 4659 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 4660{
4661 int rc = 0;
4662 TRANSACTION2_QPI_REQ *pSMB = NULL;
4663 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4664 int name_len, bytes_returned;
4665 __u16 params, byte_count;
4666
b6b38f70 4667 cFYI(1, "In GetSrvInodeNum for %s", searchName);
790fe579 4668 if (tcon == NULL)
50c2f753 4669 return -ENODEV;
1da177e4
LT		 4670
4671GetInodeNumberRetry:
4672 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
50c2f753 4673 (void **) &pSMBr);
1da177e4
LT		 4674 if (rc)
4675 return rc;
4676
1da177e4
LT		 4677 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4678 name_len =
acbbb76a
SF		 4679 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4680 searchName, PATH_MAX, nls_codepage,
4681 remap);
1da177e4
LT		 4682 name_len++; /* trailing null */
4683 name_len *= 2;
50c2f753 4684 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 4685 name_len = strnlen(searchName, PATH_MAX);
4686 name_len++; /* trailing null */
4687 strncpy(pSMB->FileName, searchName, name_len);
4688 }
4689
4690 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4691 pSMB->TotalDataCount = 0;
4692 pSMB->MaxParameterCount = cpu_to_le16(2);
4693 /* BB find exact max data count below from sess structure BB */
4694 pSMB->MaxDataCount = cpu_to_le16(4000);
4695 pSMB->MaxSetupCount = 0;
4696 pSMB->Reserved = 0;
4697 pSMB->Flags = 0;
4698 pSMB->Timeout = 0;
4699 pSMB->Reserved2 = 0;
4700 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 4701 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
1da177e4
LT		 4702 pSMB->DataCount = 0;
4703 pSMB->DataOffset = 0;
4704 pSMB->SetupCount = 1;
4705 pSMB->Reserved3 = 0;
4706 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4707 byte_count = params + 1 /* pad */ ;
4708 pSMB->TotalParameterCount = cpu_to_le16(params);
4709 pSMB->ParameterCount = pSMB->TotalParameterCount;
4710 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4711 pSMB->Reserved4 = 0;
be8e3b00 4712 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 4713 pSMB->ByteCount = cpu_to_le16(byte_count);
4714
4715 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4716 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4717 if (rc) {
b6b38f70 4718 cFYI(1, "error %d in QueryInternalInfo", rc);
1da177e4
LT		 4719 } else {
4720 /* decode response */
4721 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1da177e4 4722 /* BB also check enough total bytes returned */
820a803f 4723 if (rc || get_bcc(&pSMBr->hdr) < 2)
1da177e4
LT		 4724 /* If rc should we check for EOPNOSUPP and
4725 disable the srvino flag? or in caller? */
4726 rc = -EIO; /* bad smb */
50c2f753 4727 else {
1da177e4
LT		 4728 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4729 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
50c2f753 4730 struct file_internal_info *pfinfo;
1da177e4 4731 /* BB Do we need a cast or hash here ? */
790fe579 4732 if (count < 8) {
b6b38f70 4733 cFYI(1, "Illegal size ret in QryIntrnlInf");
1da177e4
LT		 4734 rc = -EIO;
4735 goto GetInodeNumOut;
4736 }
4737 pfinfo = (struct file_internal_info *)
4738 (data_offset + (char *) &pSMBr->hdr.Protocol);
85a6dac5 4739 *inode_number = le64_to_cpu(pfinfo->UniqueId);
1da177e4
LT		 4740 }
4741 }
4742GetInodeNumOut:
4743 cifs_buf_release(pSMB);
4744 if (rc == -EAGAIN)
4745 goto GetInodeNumberRetry;
4746 return rc;
4747}
1da177e4 4748
fec4585f
IM		 4749/* parses DFS refferal V3 structure
4750 * caller is responsible for freeing target_nodes
4751 * returns:
4752 * on success - 0
4753 * on failure - errno
4754 */
4755static int
a1fe78f1 4756parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
fec4585f
IM		 4757 unsigned int *num_of_nodes,
4758 struct dfs_info3_param **target_nodes,
2c55608f
IM		 4759 const struct nls_table *nls_codepage, int remap,
4760 const char *searchName)
fec4585f
IM		 4761{
4762 int i, rc = 0;
4763 char *data_end;
4764 bool is_unicode;
4765 struct dfs_referral_level_3 *ref;
4766
5ca33c6a
HH		 4767 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4768 is_unicode = true;
4769 else
4770 is_unicode = false;
fec4585f
IM		 4771 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4772
4773 if (*num_of_nodes < 1) {
b6b38f70
JP		 4774 cERROR(1, "num_referrals: must be at least > 0,"
4775 "but we get num_referrals = %d\n", *num_of_nodes);
fec4585f 4776 rc = -EINVAL;
a1fe78f1 4777 goto parse_DFS_referrals_exit;
fec4585f
IM		 4778 }
4779
4780 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
1d92cfd5 4781 if (ref->VersionNumber != cpu_to_le16(3)) {
b6b38f70
JP		 4782 cERROR(1, "Referrals of V%d version are not supported,"
4783 "should be V3", le16_to_cpu(ref->VersionNumber));
fec4585f 4784 rc = -EINVAL;
a1fe78f1 4785 goto parse_DFS_referrals_exit;
fec4585f
IM		 4786 }
4787
4788 /* get the upper boundary of the resp buffer */
4789 data_end = (char *)(&(pSMBr->PathConsumed)) +
4790 le16_to_cpu(pSMBr->t2.DataCount);
4791
f19159dc 4792 cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
fec4585f 4793 *num_of_nodes,
b6b38f70 4794 le32_to_cpu(pSMBr->DFSFlags));
fec4585f
IM		 4795
4796 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
4797 *num_of_nodes, GFP_KERNEL);
4798 if (*target_nodes == NULL) {
b6b38f70 4799 cERROR(1, "Failed to allocate buffer for target_nodes\n");
fec4585f 4800 rc = -ENOMEM;
a1fe78f1 4801 goto parse_DFS_referrals_exit;
fec4585f
IM		 4802 }
4803
3ad2f3fb 4804 /* collect necessary data from referrals */
fec4585f
IM		 4805 for (i = 0; i < *num_of_nodes; i++) {
4806 char *temp;
4807 int max_len;
4808 struct dfs_info3_param *node = (*target_nodes)+i;
4809
0e0d2cf3 4810 node->flags = le32_to_cpu(pSMBr->DFSFlags);
2c55608f 4811 if (is_unicode) {
331c3135
JL		 4812 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4813 GFP_KERNEL);
2920ee2b
SF		 4814 if (tmp == NULL) {
4815 rc = -ENOMEM;
4816 goto parse_DFS_referrals_exit;
4817 }
acbbb76a
SF		 4818 cifsConvertToUTF16((__le16 *) tmp, searchName,
4819 PATH_MAX, nls_codepage, remap);
4820 node->path_consumed = cifs_utf16_bytes(tmp,
69f801fc 4821 le16_to_cpu(pSMBr->PathConsumed),
2c55608f
IM		 4822 nls_codepage);
4823 kfree(tmp);
4824 } else
4825 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4826
fec4585f
IM		 4827 node->server_type = le16_to_cpu(ref->ServerType);
4828 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4829
4830 /* copy DfsPath */
4831 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4832 max_len = data_end - temp;
acbbb76a
SF		 4833 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4834 is_unicode, nls_codepage);
d8e2f53a
JL		 4835 if (!node->path_name) {
4836 rc = -ENOMEM;
a1fe78f1 4837 goto parse_DFS_referrals_exit;
066ce689 4838 }
fec4585f
IM		 4839
4840 /* copy link target UNC */
4841 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4842 max_len = data_end - temp;
acbbb76a
SF		 4843 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4844 is_unicode, nls_codepage);
d8e2f53a
JL		 4845 if (!node->node_name)
4846 rc = -ENOMEM;
fec4585f
IM		 4847 }
4848
a1fe78f1 4849parse_DFS_referrals_exit:
fec4585f
IM		 4850 if (rc) {
4851 free_dfs_info_array(*target_nodes, *num_of_nodes);
4852 *target_nodes = NULL;
4853 *num_of_nodes = 0;
4854 }
4855 return rc;
4856}
4857
1da177e4 4858int
96daf2b0 4859CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
1da177e4 4860 const unsigned char *searchName,
c2cf07d5
SF		 4861 struct dfs_info3_param **target_nodes,
4862 unsigned int *num_of_nodes,
737b758c 4863 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 4864{
4865/* TRANS2_GET_DFS_REFERRAL */
4866 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4867 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
1da177e4
LT		 4868 int rc = 0;
4869 int bytes_returned;
4870 int name_len;
1da177e4 4871 __u16 params, byte_count;
c2cf07d5
SF		 4872 *num_of_nodes = 0;
4873 *target_nodes = NULL;
1da177e4 4874
b6b38f70 4875 cFYI(1, "In GetDFSRefer the path %s", searchName);
1da177e4
LT		 4876 if (ses == NULL)
4877 return -ENODEV;
4878getDFSRetry:
4879 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4880 (void **) &pSMBr);
4881 if (rc)
4882 return rc;
50c2f753
SF		 4883
4884 /* server pointer checked in called function,
1982c344
SF		 4885 but should never be null here anyway */
4886 pSMB->hdr.Mid = GetNextMid(ses->server);
1da177e4
LT		 4887 pSMB->hdr.Tid = ses->ipc_tid;
4888 pSMB->hdr.Uid = ses->Suid;
26f57364 4889 if (ses->capabilities & CAP_STATUS32)
1da177e4 4890 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
26f57364 4891 if (ses->capabilities & CAP_DFS)
1da177e4 4892 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
1da177e4
LT		 4893
4894 if (ses->capabilities & CAP_UNICODE) {
4895 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4896 name_len =
acbbb76a
SF		 4897 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4898 searchName, PATH_MAX, nls_codepage,
4899 remap);
1da177e4
LT		 4900 name_len++; /* trailing null */
4901 name_len *= 2;
50c2f753 4902 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 4903 name_len = strnlen(searchName, PATH_MAX);
4904 name_len++; /* trailing null */
4905 strncpy(pSMB->RequestFileName, searchName, name_len);
4906 }
4907
790fe579 4908 if (ses->server) {
96daf2b0 4909 if (ses->server->sec_mode &
1a4e15a0
SF		 4910 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4911 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4912 }
4913
50c2f753 4914 pSMB->hdr.Uid = ses->Suid;
1a4e15a0 4915
1da177e4
LT		 4916 params = 2 /* level */ + name_len /*includes null */ ;
4917 pSMB->TotalDataCount = 0;
4918 pSMB->DataCount = 0;
4919 pSMB->DataOffset = 0;
4920 pSMB->MaxParameterCount = 0;
582d21e5
SF		 4921 /* BB find exact max SMB PDU from sess structure BB */
4922 pSMB->MaxDataCount = cpu_to_le16(4000);
1da177e4
LT		 4923 pSMB->MaxSetupCount = 0;
4924 pSMB->Reserved = 0;
4925 pSMB->Flags = 0;
4926 pSMB->Timeout = 0;
4927 pSMB->Reserved2 = 0;
4928 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 4929 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
1da177e4
LT		 4930 pSMB->SetupCount = 1;
4931 pSMB->Reserved3 = 0;
4932 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4933 byte_count = params + 3 /* pad */ ;
4934 pSMB->ParameterCount = cpu_to_le16(params);
4935 pSMB->TotalParameterCount = pSMB->ParameterCount;
4936 pSMB->MaxReferralLevel = cpu_to_le16(3);
be8e3b00 4937 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 4938 pSMB->ByteCount = cpu_to_le16(byte_count);
4939
4940 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4941 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4942 if (rc) {
b6b38f70 4943 cFYI(1, "Send error in GetDFSRefer = %d", rc);
c2cf07d5
SF		 4944 goto GetDFSRefExit;
4945 }
4946 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1da177e4 4947
c2cf07d5 4948 /* BB Also check if enough total bytes returned? */
820a803f 4949 if (rc || get_bcc(&pSMBr->hdr) < 17) {
c2cf07d5 4950 rc = -EIO; /* bad smb */
fec4585f
IM		 4951 goto GetDFSRefExit;
4952 }
c2cf07d5 4953
b6b38f70 4954 cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
820a803f 4955 get_bcc(&pSMBr->hdr),
b6b38f70 4956 le16_to_cpu(pSMBr->t2.DataOffset));
1da177e4 4957
fec4585f 4958 /* parse returned result into more usable form */
a1fe78f1 4959 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
2c55608f
IM		 4960 target_nodes, nls_codepage, remap,
4961 searchName);
c2cf07d5 4962
1da177e4 4963GetDFSRefExit:
0d817bc0 4964 cifs_buf_release(pSMB);
1da177e4
LT		 4965
4966 if (rc == -EAGAIN)
4967 goto getDFSRetry;
4968
4969 return rc;
4970}
4971
20962438
SF		 4972/* Query File System Info such as free space to old servers such as Win 9x */
4973int
96daf2b0 4974SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
20962438
SF		 4975{
4976/* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4977 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4978 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4979 FILE_SYSTEM_ALLOC_INFO *response_data;
4980 int rc = 0;
4981 int bytes_returned = 0;
4982 __u16 params, byte_count;
4983
b6b38f70 4984 cFYI(1, "OldQFSInfo");
20962438
SF		 4985oldQFSInfoRetry:
4986 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4987 (void **) &pSMBr);
4988 if (rc)
4989 return rc;
20962438
SF		 4990
4991 params = 2; /* level */
4992 pSMB->TotalDataCount = 0;
4993 pSMB->MaxParameterCount = cpu_to_le16(2);
4994 pSMB->MaxDataCount = cpu_to_le16(1000);
4995 pSMB->MaxSetupCount = 0;
4996 pSMB->Reserved = 0;
4997 pSMB->Flags = 0;
4998 pSMB->Timeout = 0;
4999 pSMB->Reserved2 = 0;
5000 byte_count = params + 1 /* pad */ ;
5001 pSMB->TotalParameterCount = cpu_to_le16(params);
5002 pSMB->ParameterCount = pSMB->TotalParameterCount;
5003 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5004 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5005 pSMB->DataCount = 0;
5006 pSMB->DataOffset = 0;
5007 pSMB->SetupCount = 1;
5008 pSMB->Reserved3 = 0;
5009 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5010 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
be8e3b00 5011 inc_rfc1001_len(pSMB, byte_count);
20962438
SF		 5012 pSMB->ByteCount = cpu_to_le16(byte_count);
5013
5014 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5015 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5016 if (rc) {
b6b38f70 5017 cFYI(1, "Send error in QFSInfo = %d", rc);
20962438
SF		 5018 } else { /* decode response */
5019 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5020
820a803f 5021 if (rc || get_bcc(&pSMBr->hdr) < 18)
20962438
SF		 5022 rc = -EIO; /* bad smb */
5023 else {
5024 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
b6b38f70 5025 cFYI(1, "qfsinf resp BCC: %d Offset %d",
820a803f 5026 get_bcc(&pSMBr->hdr), data_offset);
20962438 5027
50c2f753 5028 response_data = (FILE_SYSTEM_ALLOC_INFO *)
20962438
SF		 5029 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5030 FSData->f_bsize =
5031 le16_to_cpu(response_data->BytesPerSector) *
5032 le32_to_cpu(response_data->
5033 SectorsPerAllocationUnit);
5034 FSData->f_blocks =
50c2f753 5035 le32_to_cpu(response_data->TotalAllocationUnits);
20962438
SF		 5036 FSData->f_bfree = FSData->f_bavail =
5037 le32_to_cpu(response_data->FreeAllocationUnits);
b6b38f70
JP		 5038 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5039 (unsigned long long)FSData->f_blocks,
5040 (unsigned long long)FSData->f_bfree,
5041 FSData->f_bsize);
20962438
SF		 5042 }
5043 }
5044 cifs_buf_release(pSMB);
5045
5046 if (rc == -EAGAIN)
5047 goto oldQFSInfoRetry;
5048
5049 return rc;
5050}
5051
1da177e4 5052int
96daf2b0 5053CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
1da177e4
LT		 5054{
5055/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5056 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5057 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5058 FILE_SYSTEM_INFO *response_data;
5059 int rc = 0;
5060 int bytes_returned = 0;
5061 __u16 params, byte_count;
5062
b6b38f70 5063 cFYI(1, "In QFSInfo");
1da177e4
LT		 5064QFSInfoRetry:
5065 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5066 (void **) &pSMBr);
5067 if (rc)
5068 return rc;
5069
5070 params = 2; /* level */
5071 pSMB->TotalDataCount = 0;
5072 pSMB->MaxParameterCount = cpu_to_le16(2);
20962438 5073 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5074 pSMB->MaxSetupCount = 0;
5075 pSMB->Reserved = 0;
5076 pSMB->Flags = 0;
5077 pSMB->Timeout = 0;
5078 pSMB->Reserved2 = 0;
5079 byte_count = params + 1 /* pad */ ;
5080 pSMB->TotalParameterCount = cpu_to_le16(params);
5081 pSMB->ParameterCount = pSMB->TotalParameterCount;
5082 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 5083 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
1da177e4
LT		 5084 pSMB->DataCount = 0;
5085 pSMB->DataOffset = 0;
5086 pSMB->SetupCount = 1;
5087 pSMB->Reserved3 = 0;
5088 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5089 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
be8e3b00 5090 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5091 pSMB->ByteCount = cpu_to_le16(byte_count);
5092
5093 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5094 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5095 if (rc) {
b6b38f70 5096 cFYI(1, "Send error in QFSInfo = %d", rc);
1da177e4 5097 } else { /* decode response */
50c2f753 5098 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1da177e4 5099
820a803f 5100 if (rc || get_bcc(&pSMBr->hdr) < 24)
1da177e4
LT		 5101 rc = -EIO; /* bad smb */
5102 else {
5103 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1da177e4
LT		 5104
5105 response_data =
5106 (FILE_SYSTEM_INFO
5107 *) (((char *) &pSMBr->hdr.Protocol) +
5108 data_offset);
5109 FSData->f_bsize =
5110 le32_to_cpu(response_data->BytesPerSector) *
5111 le32_to_cpu(response_data->
5112 SectorsPerAllocationUnit);
5113 FSData->f_blocks =
5114 le64_to_cpu(response_data->TotalAllocationUnits);
5115 FSData->f_bfree = FSData->f_bavail =
5116 le64_to_cpu(response_data->FreeAllocationUnits);
b6b38f70
JP		 5117 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5118 (unsigned long long)FSData->f_blocks,
5119 (unsigned long long)FSData->f_bfree,
5120 FSData->f_bsize);
1da177e4
LT		 5121 }
5122 }
5123 cifs_buf_release(pSMB);
5124
5125 if (rc == -EAGAIN)
5126 goto QFSInfoRetry;
5127
5128 return rc;
5129}
5130
5131int
96daf2b0 5132CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
1da177e4
LT		 5133{
5134/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5135 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5136 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5137 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5138 int rc = 0;
5139 int bytes_returned = 0;
5140 __u16 params, byte_count;
5141
b6b38f70 5142 cFYI(1, "In QFSAttributeInfo");
1da177e4
LT		 5143QFSAttributeRetry:
5144 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5145 (void **) &pSMBr);
5146 if (rc)
5147 return rc;
5148
5149 params = 2; /* level */
5150 pSMB->TotalDataCount = 0;
5151 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5152 /* BB find exact max SMB PDU from sess structure BB */
5153 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5154 pSMB->MaxSetupCount = 0;
5155 pSMB->Reserved = 0;
5156 pSMB->Flags = 0;
5157 pSMB->Timeout = 0;
5158 pSMB->Reserved2 = 0;
5159 byte_count = params + 1 /* pad */ ;
5160 pSMB->TotalParameterCount = cpu_to_le16(params);
5161 pSMB->ParameterCount = pSMB->TotalParameterCount;
5162 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 5163 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
1da177e4
LT		 5164 pSMB->DataCount = 0;
5165 pSMB->DataOffset = 0;
5166 pSMB->SetupCount = 1;
5167 pSMB->Reserved3 = 0;
5168 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5169 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
be8e3b00 5170 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5171 pSMB->ByteCount = cpu_to_le16(byte_count);
5172
5173 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5174 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5175 if (rc) {
b6b38f70 5176 cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
1da177e4
LT		 5177 } else { /* decode response */
5178 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5179
820a803f 5180 if (rc || get_bcc(&pSMBr->hdr) < 13) {
50c2f753 5181 /* BB also check if enough bytes returned */
1da177e4
LT		 5182 rc = -EIO; /* bad smb */
5183 } else {
5184 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5185 response_data =
5186 (FILE_SYSTEM_ATTRIBUTE_INFO
5187 *) (((char *) &pSMBr->hdr.Protocol) +
5188 data_offset);
5189 memcpy(&tcon->fsAttrInfo, response_data,
26f57364 5190 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
1da177e4
LT		 5191 }
5192 }
5193 cifs_buf_release(pSMB);
5194
5195 if (rc == -EAGAIN)
5196 goto QFSAttributeRetry;
5197
5198 return rc;
5199}
5200
5201int
96daf2b0 5202CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
1da177e4
LT		 5203{
5204/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5205 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5206 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5207 FILE_SYSTEM_DEVICE_INFO *response_data;
5208 int rc = 0;
5209 int bytes_returned = 0;
5210 __u16 params, byte_count;
5211
b6b38f70 5212 cFYI(1, "In QFSDeviceInfo");
1da177e4
LT		 5213QFSDeviceRetry:
5214 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5215 (void **) &pSMBr);
5216 if (rc)
5217 return rc;
5218
5219 params = 2; /* level */
5220 pSMB->TotalDataCount = 0;
5221 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5222 /* BB find exact max SMB PDU from sess structure BB */
5223 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5224 pSMB->MaxSetupCount = 0;
5225 pSMB->Reserved = 0;
5226 pSMB->Flags = 0;
5227 pSMB->Timeout = 0;
5228 pSMB->Reserved2 = 0;
5229 byte_count = params + 1 /* pad */ ;
5230 pSMB->TotalParameterCount = cpu_to_le16(params);
5231 pSMB->ParameterCount = pSMB->TotalParameterCount;
5232 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 5233 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
1da177e4
LT		 5234
5235 pSMB->DataCount = 0;
5236 pSMB->DataOffset = 0;
5237 pSMB->SetupCount = 1;
5238 pSMB->Reserved3 = 0;
5239 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5240 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
be8e3b00 5241 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5242 pSMB->ByteCount = cpu_to_le16(byte_count);
5243
5244 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5245 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5246 if (rc) {
b6b38f70 5247 cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
1da177e4
LT		 5248 } else { /* decode response */
5249 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5250
820a803f
JL		 5251 if (rc || get_bcc(&pSMBr->hdr) <
5252 sizeof(FILE_SYSTEM_DEVICE_INFO))
1da177e4
LT		 5253 rc = -EIO; /* bad smb */
5254 else {
5255 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5256 response_data =
737b758c
SF		 5257 (FILE_SYSTEM_DEVICE_INFO *)
5258 (((char *) &pSMBr->hdr.Protocol) +
1da177e4
LT		 5259 data_offset);
5260 memcpy(&tcon->fsDevInfo, response_data,
26f57364 5261 sizeof(FILE_SYSTEM_DEVICE_INFO));
1da177e4
LT		 5262 }
5263 }
5264 cifs_buf_release(pSMB);
5265
5266 if (rc == -EAGAIN)
5267 goto QFSDeviceRetry;
5268
5269 return rc;
5270}
5271
5272int
96daf2b0 5273CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
1da177e4
LT		 5274{
5275/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5276 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5277 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5278 FILE_SYSTEM_UNIX_INFO *response_data;
5279 int rc = 0;
5280 int bytes_returned = 0;
5281 __u16 params, byte_count;
5282
b6b38f70 5283 cFYI(1, "In QFSUnixInfo");
1da177e4 5284QFSUnixRetry:
f569599a
JL		 5285 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5286 (void **) &pSMB, (void **) &pSMBr);
1da177e4
LT		 5287 if (rc)
5288 return rc;
5289
5290 params = 2; /* level */
5291 pSMB->TotalDataCount = 0;
5292 pSMB->DataCount = 0;
5293 pSMB->DataOffset = 0;
5294 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5295 /* BB find exact max SMB PDU from sess structure BB */
5296 pSMB->MaxDataCount = cpu_to_le16(100);
1da177e4
LT		 5297 pSMB->MaxSetupCount = 0;
5298 pSMB->Reserved = 0;
5299 pSMB->Flags = 0;
5300 pSMB->Timeout = 0;
5301 pSMB->Reserved2 = 0;
5302 byte_count = params + 1 /* pad */ ;
5303 pSMB->ParameterCount = cpu_to_le16(params);
5304 pSMB->TotalParameterCount = pSMB->ParameterCount;
50c2f753
SF		 5305 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5306 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
1da177e4
LT		 5307 pSMB->SetupCount = 1;
5308 pSMB->Reserved3 = 0;
5309 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5310 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
be8e3b00 5311 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5312 pSMB->ByteCount = cpu_to_le16(byte_count);
5313
5314 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5315 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5316 if (rc) {
b6b38f70 5317 cERROR(1, "Send error in QFSUnixInfo = %d", rc);
1da177e4
LT		 5318 } else { /* decode response */
5319 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5320
820a803f 5321 if (rc || get_bcc(&pSMBr->hdr) < 13) {
1da177e4
LT		 5322 rc = -EIO; /* bad smb */
5323 } else {
5324 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5325 response_data =
5326 (FILE_SYSTEM_UNIX_INFO
5327 *) (((char *) &pSMBr->hdr.Protocol) +
5328 data_offset);
5329 memcpy(&tcon->fsUnixInfo, response_data,
26f57364 5330 sizeof(FILE_SYSTEM_UNIX_INFO));
1da177e4
LT		 5331 }
5332 }
5333 cifs_buf_release(pSMB);
5334
5335 if (rc == -EAGAIN)
5336 goto QFSUnixRetry;
5337
5338
5339 return rc;
5340}
5341
ac67055e 5342int
96daf2b0 5343CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
ac67055e
JA		 5344{
5345/* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5346 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5347 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5348 int rc = 0;
5349 int bytes_returned = 0;
5350 __u16 params, param_offset, offset, byte_count;
5351
b6b38f70 5352 cFYI(1, "In SETFSUnixInfo");
ac67055e 5353SETFSUnixRetry:
f26282c9 5354 /* BB switch to small buf init to save memory */
f569599a
JL		 5355 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5356 (void **) &pSMB, (void **) &pSMBr);
ac67055e
JA		 5357 if (rc)
5358 return rc;
5359
5360 params = 4; /* 2 bytes zero followed by info level. */
5361 pSMB->MaxSetupCount = 0;
5362 pSMB->Reserved = 0;
5363 pSMB->Flags = 0;
5364 pSMB->Timeout = 0;
5365 pSMB->Reserved2 = 0;
50c2f753
SF		 5366 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5367 - 4;
ac67055e
JA		 5368 offset = param_offset + params;
5369
5370 pSMB->MaxParameterCount = cpu_to_le16(4);
582d21e5
SF		 5371 /* BB find exact max SMB PDU from sess structure BB */
5372 pSMB->MaxDataCount = cpu_to_le16(100);
ac67055e
JA		 5373 pSMB->SetupCount = 1;
5374 pSMB->Reserved3 = 0;
5375 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5376 byte_count = 1 /* pad */ + params + 12;
5377
5378 pSMB->DataCount = cpu_to_le16(12);
5379 pSMB->ParameterCount = cpu_to_le16(params);
5380 pSMB->TotalDataCount = pSMB->DataCount;
5381 pSMB->TotalParameterCount = pSMB->ParameterCount;
5382 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5383 pSMB->DataOffset = cpu_to_le16(offset);
5384
5385 /* Params. */
5386 pSMB->FileNum = 0;
5387 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5388
5389 /* Data. */
5390 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5391 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5392 pSMB->ClientUnixCap = cpu_to_le64(cap);
5393
be8e3b00 5394 inc_rfc1001_len(pSMB, byte_count);
ac67055e
JA		 5395 pSMB->ByteCount = cpu_to_le16(byte_count);
5396
5397 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5398 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5399 if (rc) {
b6b38f70 5400 cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
ac67055e
JA		 5401 } else { /* decode response */
5402 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
ad7a2926 5403 if (rc)
ac67055e 5404 rc = -EIO; /* bad smb */
ac67055e
JA		 5405 }
5406 cifs_buf_release(pSMB);
5407
5408 if (rc == -EAGAIN)
5409 goto SETFSUnixRetry;
5410
5411 return rc;
5412}
5413
5414
1da177e4
LT		 5415
5416int
96daf2b0 5417CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
737b758c 5418 struct kstatfs *FSData)
1da177e4
LT		 5419{
5420/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5421 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5422 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5423 FILE_SYSTEM_POSIX_INFO *response_data;
5424 int rc = 0;
5425 int bytes_returned = 0;
5426 __u16 params, byte_count;
5427
b6b38f70 5428 cFYI(1, "In QFSPosixInfo");
1da177e4
LT		 5429QFSPosixRetry:
5430 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5431 (void **) &pSMBr);
5432 if (rc)
5433 return rc;
5434
5435 params = 2; /* level */
5436 pSMB->TotalDataCount = 0;
5437 pSMB->DataCount = 0;
5438 pSMB->DataOffset = 0;
5439 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5440 /* BB find exact max SMB PDU from sess structure BB */
5441 pSMB->MaxDataCount = cpu_to_le16(100);
1da177e4
LT		 5442 pSMB->MaxSetupCount = 0;
5443 pSMB->Reserved = 0;
5444 pSMB->Flags = 0;
5445 pSMB->Timeout = 0;
5446 pSMB->Reserved2 = 0;
5447 byte_count = params + 1 /* pad */ ;
5448 pSMB->ParameterCount = cpu_to_le16(params);
5449 pSMB->TotalParameterCount = pSMB->ParameterCount;
50c2f753
SF		 5450 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5451 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
1da177e4
LT		 5452 pSMB->SetupCount = 1;
5453 pSMB->Reserved3 = 0;
5454 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5455 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
be8e3b00 5456 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5457 pSMB->ByteCount = cpu_to_le16(byte_count);
5458
5459 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5460 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5461 if (rc) {
b6b38f70 5462 cFYI(1, "Send error in QFSUnixInfo = %d", rc);
1da177e4
LT		 5463 } else { /* decode response */
5464 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5465
820a803f 5466 if (rc || get_bcc(&pSMBr->hdr) < 13) {
1da177e4
LT		 5467 rc = -EIO; /* bad smb */
5468 } else {
5469 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5470 response_data =
5471 (FILE_SYSTEM_POSIX_INFO
5472 *) (((char *) &pSMBr->hdr.Protocol) +
5473 data_offset);
5474 FSData->f_bsize =
5475 le32_to_cpu(response_data->BlockSize);
5476 FSData->f_blocks =
5477 le64_to_cpu(response_data->TotalBlocks);
5478 FSData->f_bfree =
5479 le64_to_cpu(response_data->BlocksAvail);
790fe579 5480 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
1da177e4
LT		 5481 FSData->f_bavail = FSData->f_bfree;
5482 } else {
5483 FSData->f_bavail =
50c2f753 5484 le64_to_cpu(response_data->UserBlocksAvail);
1da177e4 5485 }
790fe579 5486 if (response_data->TotalFileNodes != cpu_to_le64(-1))
1da177e4 5487 FSData->f_files =
50c2f753 5488 le64_to_cpu(response_data->TotalFileNodes);
790fe579 5489 if (response_data->FreeFileNodes != cpu_to_le64(-1))
1da177e4 5490 FSData->f_ffree =
50c2f753 5491 le64_to_cpu(response_data->FreeFileNodes);
1da177e4
LT		 5492 }
5493 }
5494 cifs_buf_release(pSMB);
5495
5496 if (rc == -EAGAIN)
5497 goto QFSPosixRetry;
5498
5499 return rc;
5500}
5501
5502
50c2f753
SF		 5503/* We can not use write of zero bytes trick to
5504 set file size due to need for large file support. Also note that
5505 this SetPathInfo is preferred to SetFileInfo based method in next
1da177e4
LT		 5506 routine which is only needed to work around a sharing violation bug
5507 in Samba which this routine can run into */
5508
5509int
96daf2b0 5510CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
4b18f2a9 5511 __u64 size, bool SetAllocation,
737b758c 5512 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 5513{
5514 struct smb_com_transaction2_spi_req *pSMB = NULL;
5515 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5516 struct file_end_of_file_info *parm_data;
5517 int name_len;
5518 int rc = 0;
5519 int bytes_returned = 0;
5520 __u16 params, byte_count, data_count, param_offset, offset;
5521
b6b38f70 5522 cFYI(1, "In SetEOF");
1da177e4
LT		 5523SetEOFRetry:
5524 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5525 (void **) &pSMBr);
5526 if (rc)
5527 return rc;
5528
5529 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5530 name_len =
acbbb76a
SF		 5531 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5532 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 5533 name_len++; /* trailing null */
5534 name_len *= 2;
3e87d803 5535 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 5536 name_len = strnlen(fileName, PATH_MAX);
5537 name_len++; /* trailing null */
5538 strncpy(pSMB->FileName, fileName, name_len);
5539 }
5540 params = 6 + name_len;
26f57364 5541 data_count = sizeof(struct file_end_of_file_info);
1da177e4 5542 pSMB->MaxParameterCount = cpu_to_le16(2);
3e87d803 5543 pSMB->MaxDataCount = cpu_to_le16(4100);
1da177e4
LT		 5544 pSMB->MaxSetupCount = 0;
5545 pSMB->Reserved = 0;
5546 pSMB->Flags = 0;
5547 pSMB->Timeout = 0;
5548 pSMB->Reserved2 = 0;
5549 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 5550 InformationLevel) - 4;
1da177e4 5551 offset = param_offset + params;
790fe579 5552 if (SetAllocation) {
50c2f753
SF		 5553 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5554 pSMB->InformationLevel =
5555 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5556 else
5557 pSMB->InformationLevel =
5558 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5559 } else /* Set File Size */ {
1da177e4
LT		 5560 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5561 pSMB->InformationLevel =
50c2f753 5562 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
1da177e4
LT		 5563 else
5564 pSMB->InformationLevel =
50c2f753 5565 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
1da177e4
LT		 5566 }
5567
5568 parm_data =
5569 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5570 offset);
5571 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5572 pSMB->DataOffset = cpu_to_le16(offset);
5573 pSMB->SetupCount = 1;
5574 pSMB->Reserved3 = 0;
5575 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5576 byte_count = 3 /* pad */ + params + data_count;
5577 pSMB->DataCount = cpu_to_le16(data_count);
5578 pSMB->TotalDataCount = pSMB->DataCount;
5579 pSMB->ParameterCount = cpu_to_le16(params);
5580 pSMB->TotalParameterCount = pSMB->ParameterCount;
5581 pSMB->Reserved4 = 0;
be8e3b00 5582 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 5583 parm_data->FileSize = cpu_to_le64(size);
5584 pSMB->ByteCount = cpu_to_le16(byte_count);
5585 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5586 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 5587 if (rc)
b6b38f70 5588 cFYI(1, "SetPathInfo (file size) returned %d", rc);
1da177e4
LT		 5589
5590 cifs_buf_release(pSMB);
5591
5592 if (rc == -EAGAIN)
5593 goto SetEOFRetry;
5594
5595 return rc;
5596}
5597
5598int
96daf2b0 5599CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
4b18f2a9 5600 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
1da177e4
LT		 5601{
5602 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1da177e4
LT		 5603 struct file_end_of_file_info *parm_data;
5604 int rc = 0;
1da177e4
LT		 5605 __u16 params, param_offset, offset, byte_count, count;
5606
b6b38f70
JP		 5607 cFYI(1, "SetFileSize (via SetFileInfo) %lld",
5608 (long long)size);
cd63499c
SF		 5609 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5610
1da177e4
LT		 5611 if (rc)
5612 return rc;
5613
5614 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5615 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
50c2f753 5616
1da177e4
LT		 5617 params = 6;
5618 pSMB->MaxSetupCount = 0;
5619 pSMB->Reserved = 0;
5620 pSMB->Flags = 0;
5621 pSMB->Timeout = 0;
5622 pSMB->Reserved2 = 0;
5623 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5624 offset = param_offset + params;
5625
1da177e4
LT		 5626 count = sizeof(struct file_end_of_file_info);
5627 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5628 /* BB find exact max SMB PDU from sess structure BB */
5629 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5630 pSMB->SetupCount = 1;
5631 pSMB->Reserved3 = 0;
5632 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5633 byte_count = 3 /* pad */ + params + count;
5634 pSMB->DataCount = cpu_to_le16(count);
5635 pSMB->ParameterCount = cpu_to_le16(params);
5636 pSMB->TotalDataCount = pSMB->DataCount;
5637 pSMB->TotalParameterCount = pSMB->ParameterCount;
5638 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5639 parm_data =
50c2f753
SF		 5640 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5641 + offset);
1da177e4
LT		 5642 pSMB->DataOffset = cpu_to_le16(offset);
5643 parm_data->FileSize = cpu_to_le64(size);
5644 pSMB->Fid = fid;
790fe579 5645 if (SetAllocation) {
1da177e4
LT		 5646 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5647 pSMB->InformationLevel =
5648 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5649 else
5650 pSMB->InformationLevel =
5651 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
50c2f753 5652 } else /* Set File Size */ {
1da177e4
LT		 5653 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5654 pSMB->InformationLevel =
50c2f753 5655 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
1da177e4
LT		 5656 else
5657 pSMB->InformationLevel =
50c2f753 5658 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
1da177e4
LT		 5659 }
5660 pSMB->Reserved4 = 0;
be8e3b00 5661 inc_rfc1001_len(pSMB, byte_count);
1da177e4 5662 pSMB->ByteCount = cpu_to_le16(byte_count);
792af7b0 5663 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
1da177e4 5664 if (rc) {
b6b38f70 5665 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
1da177e4
LT		 5666 }
5667
50c2f753 5668 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 5669 since file handle passed in no longer valid */
5670
5671 return rc;
5672}
5673
50c2f753 5674/* Some legacy servers such as NT4 require that the file times be set on
1da177e4
LT		 5675 an open handle, rather than by pathname - this is awkward due to
5676 potential access conflicts on the open, but it is unavoidable for these
5677 old servers since the only other choice is to go from 100 nanosecond DCE
5678 time and resort to the original setpathinfo level which takes the ancient
5679 DOS time format with 2 second granularity */
5680int
96daf2b0 5681CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
2dd2dfa0 5682 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
1da177e4
LT		 5683{
5684 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1da177e4
LT		 5685 char *data_offset;
5686 int rc = 0;
1da177e4
LT		 5687 __u16 params, param_offset, offset, byte_count, count;
5688
b6b38f70 5689 cFYI(1, "Set Times (via SetFileInfo)");
cd63499c
SF		 5690 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5691
1da177e4
LT		 5692 if (rc)
5693 return rc;
5694
2dd2dfa0
JL		 5695 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5696 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
50c2f753 5697
1da177e4
LT		 5698 params = 6;
5699 pSMB->MaxSetupCount = 0;
5700 pSMB->Reserved = 0;
5701 pSMB->Flags = 0;
5702 pSMB->Timeout = 0;
5703 pSMB->Reserved2 = 0;
5704 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5705 offset = param_offset + params;
5706
50c2f753 5707 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1da177e4 5708
26f57364 5709 count = sizeof(FILE_BASIC_INFO);
1da177e4 5710 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5711 /* BB find max SMB PDU from sess */
5712 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5713 pSMB->SetupCount = 1;
5714 pSMB->Reserved3 = 0;
5715 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5716 byte_count = 3 /* pad */ + params + count;
5717 pSMB->DataCount = cpu_to_le16(count);
5718 pSMB->ParameterCount = cpu_to_le16(params);
5719 pSMB->TotalDataCount = pSMB->DataCount;
5720 pSMB->TotalParameterCount = pSMB->ParameterCount;
5721 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5722 pSMB->DataOffset = cpu_to_le16(offset);
5723 pSMB->Fid = fid;
5724 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5725 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5726 else
5727 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5728 pSMB->Reserved4 = 0;
be8e3b00 5729 inc_rfc1001_len(pSMB, byte_count);
1da177e4 5730 pSMB->ByteCount = cpu_to_le16(byte_count);
50c2f753 5731 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
792af7b0 5732 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
ad7a2926 5733 if (rc)
b6b38f70 5734 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
1da177e4 5735
50c2f753 5736 /* Note: On -EAGAIN error only caller can retry on handle based calls
1da177e4
LT		 5737 since file handle passed in no longer valid */
5738
5739 return rc;
5740}
5741
6d22f098 5742int
96daf2b0 5743CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
6d22f098
JL		 5744 bool delete_file, __u16 fid, __u32 pid_of_opener)
5745{
5746 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5747 char *data_offset;
5748 int rc = 0;
5749 __u16 params, param_offset, offset, byte_count, count;
5750
b6b38f70 5751 cFYI(1, "Set File Disposition (via SetFileInfo)");
6d22f098
JL		 5752 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5753
5754 if (rc)
5755 return rc;
5756
5757 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5758 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5759
5760 params = 6;
5761 pSMB->MaxSetupCount = 0;
5762 pSMB->Reserved = 0;
5763 pSMB->Flags = 0;
5764 pSMB->Timeout = 0;
5765 pSMB->Reserved2 = 0;
5766 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5767 offset = param_offset + params;
5768
5769 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5770
5771 count = 1;
5772 pSMB->MaxParameterCount = cpu_to_le16(2);
5773 /* BB find max SMB PDU from sess */
5774 pSMB->MaxDataCount = cpu_to_le16(1000);
5775 pSMB->SetupCount = 1;
5776 pSMB->Reserved3 = 0;
5777 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5778 byte_count = 3 /* pad */ + params + count;
5779 pSMB->DataCount = cpu_to_le16(count);
5780 pSMB->ParameterCount = cpu_to_le16(params);
5781 pSMB->TotalDataCount = pSMB->DataCount;
5782 pSMB->TotalParameterCount = pSMB->ParameterCount;
5783 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5784 pSMB->DataOffset = cpu_to_le16(offset);
5785 pSMB->Fid = fid;
5786 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5787 pSMB->Reserved4 = 0;
be8e3b00 5788 inc_rfc1001_len(pSMB, byte_count);
6d22f098
JL		 5789 pSMB->ByteCount = cpu_to_le16(byte_count);
5790 *data_offset = delete_file ? 1 : 0;
792af7b0 5791 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
6d22f098 5792 if (rc)
b6b38f70 5793 cFYI(1, "Send error in SetFileDisposition = %d", rc);
6d22f098
JL		 5794
5795 return rc;
5796}
1da177e4
LT		 5797
5798int
96daf2b0 5799CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
6fc000e5
JL		 5800 const char *fileName, const FILE_BASIC_INFO *data,
5801 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 5802{
5803 TRANSACTION2_SPI_REQ *pSMB = NULL;
5804 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5805 int name_len;
5806 int rc = 0;
5807 int bytes_returned = 0;
5808 char *data_offset;
5809 __u16 params, param_offset, offset, byte_count, count;
5810
b6b38f70 5811 cFYI(1, "In SetTimes");
1da177e4
LT		 5812
5813SetTimesRetry:
5814 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5815 (void **) &pSMBr);
5816 if (rc)
5817 return rc;
5818
5819 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5820 name_len =
acbbb76a
SF		 5821 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5822 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 5823 name_len++; /* trailing null */
5824 name_len *= 2;
50c2f753 5825 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 5826 name_len = strnlen(fileName, PATH_MAX);
5827 name_len++; /* trailing null */
5828 strncpy(pSMB->FileName, fileName, name_len);
5829 }
5830
5831 params = 6 + name_len;
26f57364 5832 count = sizeof(FILE_BASIC_INFO);
1da177e4 5833 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 5834 /* BB find max SMB PDU from sess structure BB */
5835 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 5836 pSMB->MaxSetupCount = 0;
5837 pSMB->Reserved = 0;
5838 pSMB->Flags = 0;
5839 pSMB->Timeout = 0;
5840 pSMB->Reserved2 = 0;
5841 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 5842 InformationLevel) - 4;
1da177e4
LT		 5843 offset = param_offset + params;
5844 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5845 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5846 pSMB->DataOffset = cpu_to_le16(offset);
5847 pSMB->SetupCount = 1;
5848 pSMB->Reserved3 = 0;
5849 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5850 byte_count = 3 /* pad */ + params + count;
5851
5852 pSMB->DataCount = cpu_to_le16(count);
5853 pSMB->ParameterCount = cpu_to_le16(params);
5854 pSMB->TotalDataCount = pSMB->DataCount;
5855 pSMB->TotalParameterCount = pSMB->ParameterCount;
5856 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5857 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5858 else
5859 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5860 pSMB->Reserved4 = 0;
be8e3b00 5861 inc_rfc1001_len(pSMB, byte_count);
26f57364 5862 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
1da177e4
LT		 5863 pSMB->ByteCount = cpu_to_le16(byte_count);
5864 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5865 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 5866 if (rc)
b6b38f70 5867 cFYI(1, "SetPathInfo (times) returned %d", rc);
1da177e4
LT		 5868
5869 cifs_buf_release(pSMB);
5870
5871 if (rc == -EAGAIN)
5872 goto SetTimesRetry;
5873
5874 return rc;
5875}
5876
5877/* Can not be used to set time stamps yet (due to old DOS time format) */
5878/* Can be used to set attributes */
5879#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5880 handling it anyway and NT4 was what we thought it would be needed for
5881 Do not delete it until we prove whether needed for Win9x though */
5882int
96daf2b0 5883CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
1da177e4
LT		 5884 __u16 dos_attrs, const struct nls_table *nls_codepage)
5885{
5886 SETATTR_REQ *pSMB = NULL;
5887 SETATTR_RSP *pSMBr = NULL;
5888 int rc = 0;
5889 int bytes_returned;
5890 int name_len;
5891
b6b38f70 5892 cFYI(1, "In SetAttrLegacy");
1da177e4
LT		 5893
5894SetAttrLgcyRetry:
5895 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5896 (void **) &pSMBr);
5897 if (rc)
5898 return rc;
5899
5900 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5901 name_len =
acbbb76a
SF		 5902 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5903 PATH_MAX, nls_codepage);
1da177e4
LT		 5904 name_len++; /* trailing null */
5905 name_len *= 2;
50c2f753 5906 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 5907 name_len = strnlen(fileName, PATH_MAX);
5908 name_len++; /* trailing null */
5909 strncpy(pSMB->fileName, fileName, name_len);
5910 }
5911 pSMB->attr = cpu_to_le16(dos_attrs);
5912 pSMB->BufferFormat = 0x04;
be8e3b00 5913 inc_rfc1001_len(pSMB, name_len + 1);
1da177e4
LT		 5914 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5915 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5916 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 5917 if (rc)
b6b38f70 5918 cFYI(1, "Error in LegacySetAttr = %d", rc);
1da177e4
LT		 5919
5920 cifs_buf_release(pSMB);
5921
5922 if (rc == -EAGAIN)
5923 goto SetAttrLgcyRetry;
5924
5925 return rc;
5926}
5927#endif /* temporarily unneeded SetAttr legacy function */
5928
654cf14a
JL		 5929static void
5930cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5931 const struct cifs_unix_set_info_args *args)
5932{
5933 u64 mode = args->mode;
5934
5935 /*
5936 * Samba server ignores set of file size to zero due to bugs in some
5937 * older clients, but we should be precise - we use SetFileSize to
5938 * set file size and do not want to truncate file size to zero
25985edc 5939 * accidentally as happened on one Samba server beta by putting
654cf14a
JL		 5940 * zero instead of -1 here
5941 */
5942 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5943 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5944 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5945 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5946 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5947 data_offset->Uid = cpu_to_le64(args->uid);
5948 data_offset->Gid = cpu_to_le64(args->gid);
5949 /* better to leave device as zero when it is */
5950 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5951 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5952 data_offset->Permissions = cpu_to_le64(mode);
5953
5954 if (S_ISREG(mode))
5955 data_offset->Type = cpu_to_le32(UNIX_FILE);
5956 else if (S_ISDIR(mode))
5957 data_offset->Type = cpu_to_le32(UNIX_DIR);
5958 else if (S_ISLNK(mode))
5959 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5960 else if (S_ISCHR(mode))
5961 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5962 else if (S_ISBLK(mode))
5963 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5964 else if (S_ISFIFO(mode))
5965 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5966 else if (S_ISSOCK(mode))
5967 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5968}
5969
3bbeeb3c 5970int
96daf2b0 5971CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
3bbeeb3c
JL		 5972 const struct cifs_unix_set_info_args *args,
5973 u16 fid, u32 pid_of_opener)
5974{
5975 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5976 FILE_UNIX_BASIC_INFO *data_offset;
5977 int rc = 0;
5978 u16 params, param_offset, offset, byte_count, count;
5979
b6b38f70 5980 cFYI(1, "Set Unix Info (via SetFileInfo)");
3bbeeb3c
JL		 5981 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5982
5983 if (rc)
5984 return rc;
5985
5986 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5987 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5988
5989 params = 6;
5990 pSMB->MaxSetupCount = 0;
5991 pSMB->Reserved = 0;
5992 pSMB->Flags = 0;
5993 pSMB->Timeout = 0;
5994 pSMB->Reserved2 = 0;
5995 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5996 offset = param_offset + params;
5997
5998 data_offset = (FILE_UNIX_BASIC_INFO *)
5999 ((char *)(&pSMB->hdr.Protocol) + offset);
6000 count = sizeof(FILE_UNIX_BASIC_INFO);
6001
6002 pSMB->MaxParameterCount = cpu_to_le16(2);
6003 /* BB find max SMB PDU from sess */
6004 pSMB->MaxDataCount = cpu_to_le16(1000);
6005 pSMB->SetupCount = 1;
6006 pSMB->Reserved3 = 0;
6007 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
6008 byte_count = 3 /* pad */ + params + count;
6009 pSMB->DataCount = cpu_to_le16(count);
6010 pSMB->ParameterCount = cpu_to_le16(params);
6011 pSMB->TotalDataCount = pSMB->DataCount;
6012 pSMB->TotalParameterCount = pSMB->ParameterCount;
6013 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6014 pSMB->DataOffset = cpu_to_le16(offset);
6015 pSMB->Fid = fid;
6016 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6017 pSMB->Reserved4 = 0;
be8e3b00 6018 inc_rfc1001_len(pSMB, byte_count);
3bbeeb3c
JL		 6019 pSMB->ByteCount = cpu_to_le16(byte_count);
6020
6021 cifs_fill_unix_set_info(data_offset, args);
6022
792af7b0 6023 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
3bbeeb3c 6024 if (rc)
b6b38f70 6025 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
3bbeeb3c
JL		 6026
6027 /* Note: On -EAGAIN error only caller can retry on handle based calls
6028 since file handle passed in no longer valid */
6029
6030 return rc;
6031}
6032
1da177e4 6033int
96daf2b0 6034CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
01ea95e3
JL		 6035 const struct cifs_unix_set_info_args *args,
6036 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 6037{
6038 TRANSACTION2_SPI_REQ *pSMB = NULL;
6039 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6040 int name_len;
6041 int rc = 0;
6042 int bytes_returned = 0;
6043 FILE_UNIX_BASIC_INFO *data_offset;
6044 __u16 params, param_offset, offset, count, byte_count;
6045
b6b38f70 6046 cFYI(1, "In SetUID/GID/Mode");
1da177e4
LT		 6047setPermsRetry:
6048 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6049 (void **) &pSMBr);
6050 if (rc)
6051 return rc;
6052
6053 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6054 name_len =
acbbb76a
SF		 6055 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6056 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 6057 name_len++; /* trailing null */
6058 name_len *= 2;
3e87d803 6059 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 6060 name_len = strnlen(fileName, PATH_MAX);
6061 name_len++; /* trailing null */
6062 strncpy(pSMB->FileName, fileName, name_len);
6063 }
6064
6065 params = 6 + name_len;
26f57364 6066 count = sizeof(FILE_UNIX_BASIC_INFO);
1da177e4 6067 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 6068 /* BB find max SMB PDU from sess structure BB */
6069 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 6070 pSMB->MaxSetupCount = 0;
6071 pSMB->Reserved = 0;
6072 pSMB->Flags = 0;
6073 pSMB->Timeout = 0;
6074 pSMB->Reserved2 = 0;
6075 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 6076 InformationLevel) - 4;
1da177e4
LT		 6077 offset = param_offset + params;
6078 data_offset =
6079 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6080 offset);
6081 memset(data_offset, 0, count);
6082 pSMB->DataOffset = cpu_to_le16(offset);
6083 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6084 pSMB->SetupCount = 1;
6085 pSMB->Reserved3 = 0;
6086 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6087 byte_count = 3 /* pad */ + params + count;
6088 pSMB->ParameterCount = cpu_to_le16(params);
6089 pSMB->DataCount = cpu_to_le16(count);
6090 pSMB->TotalParameterCount = pSMB->ParameterCount;
6091 pSMB->TotalDataCount = pSMB->DataCount;
6092 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6093 pSMB->Reserved4 = 0;
be8e3b00 6094 inc_rfc1001_len(pSMB, byte_count);
1da177e4 6095
654cf14a 6096 cifs_fill_unix_set_info(data_offset, args);
1da177e4
LT		 6097
6098 pSMB->ByteCount = cpu_to_le16(byte_count);
6099 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6100 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 6101 if (rc)
b6b38f70 6102 cFYI(1, "SetPathInfo (perms) returned %d", rc);
1da177e4 6103
0d817bc0 6104 cifs_buf_release(pSMB);
1da177e4
LT		 6105 if (rc == -EAGAIN)
6106 goto setPermsRetry;
6107 return rc;
6108}
6109
1da177e4 6110#ifdef CONFIG_CIFS_XATTR
31c0519f
JL		 6111/*
6112 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6113 * function used by listxattr and getxattr type calls. When ea_name is set,
6114 * it looks for that attribute name and stuffs that value into the EAData
6115 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6116 * buffer. In both cases, the return value is either the length of the
6117 * resulting data or a negative error code. If EAData is a NULL pointer then
6118 * the data isn't copied to it, but the length is returned.
6119 */
1da177e4 6120ssize_t
96daf2b0 6121CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
31c0519f
JL		 6122 const unsigned char *searchName, const unsigned char *ea_name,
6123 char *EAData, size_t buf_size,
6124 const struct nls_table *nls_codepage, int remap)
1da177e4
LT		 6125{
6126 /* BB assumes one setup word */
6127 TRANSACTION2_QPI_REQ *pSMB = NULL;
6128 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6129 int rc = 0;
6130 int bytes_returned;
6e462b9f 6131 int list_len;
f0d3868b 6132 struct fealist *ea_response_data;
50c2f753
SF		 6133 struct fea *temp_fea;
6134 char *temp_ptr;
0cd126b5 6135 char *end_of_smb;
f0d3868b 6136 __u16 params, byte_count, data_offset;
5980fc96 6137 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
1da177e4 6138
b6b38f70 6139 cFYI(1, "In Query All EAs path %s", searchName);
1da177e4
LT		 6140QAllEAsRetry:
6141 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6142 (void **) &pSMBr);
6143 if (rc)
6144 return rc;
6145
6146 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6e462b9f 6147 list_len =
acbbb76a
SF		 6148 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6149 PATH_MAX, nls_codepage, remap);
6e462b9f
JL		 6150 list_len++; /* trailing null */
6151 list_len *= 2;
1da177e4 6152 } else { /* BB improve the check for buffer overruns BB */
6e462b9f
JL		 6153 list_len = strnlen(searchName, PATH_MAX);
6154 list_len++; /* trailing null */
6155 strncpy(pSMB->FileName, searchName, list_len);
1da177e4
LT		 6156 }
6157
6e462b9f 6158 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
1da177e4
LT		 6159 pSMB->TotalDataCount = 0;
6160 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5 6161 /* BB find exact max SMB PDU from sess structure BB */
e529614a 6162 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
1da177e4
LT		 6163 pSMB->MaxSetupCount = 0;
6164 pSMB->Reserved = 0;
6165 pSMB->Flags = 0;
6166 pSMB->Timeout = 0;
6167 pSMB->Reserved2 = 0;
6168 pSMB->ParameterOffset = cpu_to_le16(offsetof(
50c2f753 6169 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
1da177e4
LT		 6170 pSMB->DataCount = 0;
6171 pSMB->DataOffset = 0;
6172 pSMB->SetupCount = 1;
6173 pSMB->Reserved3 = 0;
6174 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6175 byte_count = params + 1 /* pad */ ;
6176 pSMB->TotalParameterCount = cpu_to_le16(params);
6177 pSMB->ParameterCount = pSMB->TotalParameterCount;
6178 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6179 pSMB->Reserved4 = 0;
be8e3b00 6180 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 6181 pSMB->ByteCount = cpu_to_le16(byte_count);
6182
6183 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6184 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6185 if (rc) {
b6b38f70 6186 cFYI(1, "Send error in QueryAllEAs = %d", rc);
f0d3868b
JL		 6187 goto QAllEAsOut;
6188 }
1da177e4 6189
f0d3868b
JL		 6190
6191 /* BB also check enough total bytes returned */
6192 /* BB we need to improve the validity checking
6193 of these trans2 responses */
6194
6195 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
820a803f 6196 if (rc || get_bcc(&pSMBr->hdr) < 4) {
f0d3868b
JL		 6197 rc = -EIO; /* bad smb */
6198 goto QAllEAsOut;
6199 }
6200
6201 /* check that length of list is not more than bcc */
6202 /* check that each entry does not go beyond length
6203 of list */
6204 /* check that each element of each entry does not
6205 go beyond end of list */
6206 /* validate_trans2_offsets() */
6207 /* BB check if start of smb + data_offset > &bcc+ bcc */
6208
6209 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6210 ea_response_data = (struct fealist *)
6211 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6212
6e462b9f 6213 list_len = le32_to_cpu(ea_response_data->list_len);
b6b38f70 6214 cFYI(1, "ea length %d", list_len);
6e462b9f 6215 if (list_len <= 8) {
b6b38f70 6216 cFYI(1, "empty EA list returned from server");
f0d3868b
JL		 6217 goto QAllEAsOut;
6218 }
6219
0cd126b5 6220 /* make sure list_len doesn't go past end of SMB */
690c522f 6221 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
0cd126b5 6222 if ((char *)ea_response_data + list_len > end_of_smb) {
b6b38f70 6223 cFYI(1, "EA list appears to go beyond SMB");
0cd126b5
JL		 6224 rc = -EIO;
6225 goto QAllEAsOut;
6226 }
6227
f0d3868b 6228 /* account for ea list len */
6e462b9f 6229 list_len -= 4;
f0d3868b
JL		 6230 temp_fea = ea_response_data->list;
6231 temp_ptr = (char *)temp_fea;
6e462b9f 6232 while (list_len > 0) {
122ca007 6233 unsigned int name_len;
f0d3868b 6234 __u16 value_len;
0cd126b5 6235
6e462b9f 6236 list_len -= 4;
f0d3868b 6237 temp_ptr += 4;
0cd126b5
JL		 6238 /* make sure we can read name_len and value_len */
6239 if (list_len < 0) {
b6b38f70 6240 cFYI(1, "EA entry goes beyond length of list");
0cd126b5
JL		 6241 rc = -EIO;
6242 goto QAllEAsOut;
6243 }
6244
6245 name_len = temp_fea->name_len;
6246 value_len = le16_to_cpu(temp_fea->value_len);
6247 list_len -= name_len + 1 + value_len;
6248 if (list_len < 0) {
b6b38f70 6249 cFYI(1, "EA entry goes beyond length of list");
0cd126b5
JL		 6250 rc = -EIO;
6251 goto QAllEAsOut;
6252 }
6253
31c0519f 6254 if (ea_name) {
91d065c4 6255 if (ea_name_len == name_len &&
ac423446 6256 memcmp(ea_name, temp_ptr, name_len) == 0) {
31c0519f
JL		 6257 temp_ptr += name_len + 1;
6258 rc = value_len;
6259 if (buf_size == 0)
6260 goto QAllEAsOut;
6261 if ((size_t)value_len > buf_size) {
6262 rc = -ERANGE;
6263 goto QAllEAsOut;
6264 }
6265 memcpy(EAData, temp_ptr, value_len);
6266 goto QAllEAsOut;
6267 }
f0d3868b 6268 } else {
31c0519f
JL		 6269 /* account for prefix user. and trailing null */
6270 rc += (5 + 1 + name_len);
6271 if (rc < (int) buf_size) {
6272 memcpy(EAData, "user.", 5);
6273 EAData += 5;
6274 memcpy(EAData, temp_ptr, name_len);
6275 EAData += name_len;
6276 /* null terminate name */
6277 *EAData = 0;
6278 ++EAData;
6279 } else if (buf_size == 0) {
6280 /* skip copy - calc size only */
6281 } else {
6282 /* stop before overrun buffer */
6283 rc = -ERANGE;
6284 break;
6285 }
1da177e4 6286 }
0cd126b5 6287 temp_ptr += name_len + 1 + value_len;
f0d3868b 6288 temp_fea = (struct fea *)temp_ptr;
1da177e4 6289 }
f0d3868b 6290
31c0519f
JL		 6291 /* didn't find the named attribute */
6292 if (ea_name)
6293 rc = -ENODATA;
6294
f0d3868b 6295QAllEAsOut:
0d817bc0 6296 cifs_buf_release(pSMB);
1da177e4
LT		 6297 if (rc == -EAGAIN)
6298 goto QAllEAsRetry;
6299
6300 return (ssize_t)rc;
6301}
6302
1da177e4 6303int
96daf2b0 6304CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
50c2f753
SF		 6305 const char *ea_name, const void *ea_value,
6306 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6307 int remap)
1da177e4
LT		 6308{
6309 struct smb_com_transaction2_spi_req *pSMB = NULL;
6310 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6311 struct fealist *parm_data;
6312 int name_len;
6313 int rc = 0;
6314 int bytes_returned = 0;
6315 __u16 params, param_offset, byte_count, offset, count;
6316
b6b38f70 6317 cFYI(1, "In SetEA");
1da177e4
LT		 6318SetEARetry:
6319 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6320 (void **) &pSMBr);
6321 if (rc)
6322 return rc;
6323
6324 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6325 name_len =
acbbb76a
SF		 6326 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6327 PATH_MAX, nls_codepage, remap);
1da177e4
LT		 6328 name_len++; /* trailing null */
6329 name_len *= 2;
50c2f753 6330 } else { /* BB improve the check for buffer overruns BB */
1da177e4
LT		 6331 name_len = strnlen(fileName, PATH_MAX);
6332 name_len++; /* trailing null */
6333 strncpy(pSMB->FileName, fileName, name_len);
6334 }
6335
6336 params = 6 + name_len;
6337
6338 /* done calculating parms using name_len of file name,
6339 now use name_len to calculate length of ea name
6340 we are going to create in the inode xattrs */
790fe579 6341 if (ea_name == NULL)
1da177e4
LT		 6342 name_len = 0;
6343 else
50c2f753 6344 name_len = strnlen(ea_name, 255);
1da177e4 6345
dae5dbdb 6346 count = sizeof(*parm_data) + ea_value_len + name_len;
1da177e4 6347 pSMB->MaxParameterCount = cpu_to_le16(2);
582d21e5
SF		 6348 /* BB find max SMB PDU from sess */
6349 pSMB->MaxDataCount = cpu_to_le16(1000);
1da177e4
LT		 6350 pSMB->MaxSetupCount = 0;
6351 pSMB->Reserved = 0;
6352 pSMB->Flags = 0;
6353 pSMB->Timeout = 0;
6354 pSMB->Reserved2 = 0;
6355 param_offset = offsetof(struct smb_com_transaction2_spi_req,
50c2f753 6356 InformationLevel) - 4;
1da177e4
LT		 6357 offset = param_offset + params;
6358 pSMB->InformationLevel =
6359 cpu_to_le16(SMB_SET_FILE_EA);
6360
6361 parm_data =
6362 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6363 offset);
6364 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6365 pSMB->DataOffset = cpu_to_le16(offset);
6366 pSMB->SetupCount = 1;
6367 pSMB->Reserved3 = 0;
6368 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6369 byte_count = 3 /* pad */ + params + count;
6370 pSMB->DataCount = cpu_to_le16(count);
6371 parm_data->list_len = cpu_to_le32(count);
6372 parm_data->list[0].EA_flags = 0;
6373 /* we checked above that name len is less than 255 */
53b3531b 6374 parm_data->list[0].name_len = (__u8)name_len;
1da177e4 6375 /* EA names are always ASCII */
790fe579 6376 if (ea_name)
50c2f753 6377 strncpy(parm_data->list[0].name, ea_name, name_len);
1da177e4
LT		 6378 parm_data->list[0].name[name_len] = 0;
6379 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6380 /* caller ensures that ea_value_len is less than 64K but
6381 we need to ensure that it fits within the smb */
6382
50c2f753
SF		 6383 /*BB add length check to see if it would fit in
6384 negotiated SMB buffer size BB */
790fe579
SF		 6385 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6386 if (ea_value_len)
50c2f753
SF		 6387 memcpy(parm_data->list[0].name+name_len+1,
6388 ea_value, ea_value_len);
1da177e4
LT		 6389
6390 pSMB->TotalDataCount = pSMB->DataCount;
6391 pSMB->ParameterCount = cpu_to_le16(params);
6392 pSMB->TotalParameterCount = pSMB->ParameterCount;
6393 pSMB->Reserved4 = 0;
be8e3b00 6394 inc_rfc1001_len(pSMB, byte_count);
1da177e4
LT		 6395 pSMB->ByteCount = cpu_to_le16(byte_count);
6396 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6397 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
ad7a2926 6398 if (rc)
b6b38f70 6399 cFYI(1, "SetPathInfo (EA) returned %d", rc);
1da177e4
LT		 6400
6401 cifs_buf_release(pSMB);
6402
6403 if (rc == -EAGAIN)
6404 goto SetEARetry;
6405
6406 return rc;
6407}
1da177e4 6408#endif
0eff0e26
SF		 6409
6410#ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6411/*
6412 * Years ago the kernel added a "dnotify" function for Samba server,
6413 * to allow network clients (such as Windows) to display updated
6414 * lists of files in directory listings automatically when
6415 * files are added by one user when another user has the
6416 * same directory open on their desktop. The Linux cifs kernel
6417 * client hooked into the kernel side of this interface for
6418 * the same reason, but ironically when the VFS moved from
6419 * "dnotify" to "inotify" it became harder to plug in Linux
6420 * network file system clients (the most obvious use case
6421 * for notify interfaces is when multiple users can update
6422 * the contents of the same directory - exactly what network
6423 * file systems can do) although the server (Samba) could
6424 * still use it. For the short term we leave the worker
6425 * function ifdeffed out (below) until inotify is fixed
6426 * in the VFS to make it easier to plug in network file
6427 * system clients. If inotify turns out to be permanently
6428 * incompatible for network fs clients, we could instead simply
6429 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6430 */
96daf2b0 6431int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
0eff0e26
SF		 6432 const int notify_subdirs, const __u16 netfid,
6433 __u32 filter, struct file *pfile, int multishot,
6434 const struct nls_table *nls_codepage)
6435{
6436 int rc = 0;
6437 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6438 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6439 struct dir_notify_req *dnotify_req;
6440 int bytes_returned;
6441
6442 cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
6443 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6444 (void **) &pSMBr);
6445 if (rc)
6446 return rc;
6447
6448 pSMB->TotalParameterCount = 0 ;
6449 pSMB->TotalDataCount = 0;
6450 pSMB->MaxParameterCount = cpu_to_le32(2);
c974befa 6451 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
0eff0e26
SF		 6452 pSMB->MaxSetupCount = 4;
6453 pSMB->Reserved = 0;
6454 pSMB->ParameterOffset = 0;
6455 pSMB->DataCount = 0;
6456 pSMB->DataOffset = 0;
6457 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6458 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6459 pSMB->ParameterCount = pSMB->TotalParameterCount;
6460 if (notify_subdirs)
6461 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6462 pSMB->Reserved2 = 0;
6463 pSMB->CompletionFilter = cpu_to_le32(filter);
6464 pSMB->Fid = netfid; /* file handle always le */
6465 pSMB->ByteCount = 0;
6466
6467 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6468 (struct smb_hdr *)pSMBr, &bytes_returned,
6469 CIFS_ASYNC_OP);
6470 if (rc) {
6471 cFYI(1, "Error in Notify = %d", rc);
6472 } else {
6473 /* Add file to outstanding requests */
6474 /* BB change to kmem cache alloc */
6475 dnotify_req = kmalloc(
6476 sizeof(struct dir_notify_req),
6477 GFP_KERNEL);
6478 if (dnotify_req) {
6479 dnotify_req->Pid = pSMB->hdr.Pid;
6480 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6481 dnotify_req->Mid = pSMB->hdr.Mid;
6482 dnotify_req->Tid = pSMB->hdr.Tid;
6483 dnotify_req->Uid = pSMB->hdr.Uid;
6484 dnotify_req->netfid = netfid;
6485 dnotify_req->pfile = pfile;
6486 dnotify_req->filter = filter;
6487 dnotify_req->multishot = multishot;
6488 spin_lock(&GlobalMid_Lock);
6489 list_add_tail(&dnotify_req->lhead,
6490 &GlobalDnotifyReqList);
6491 spin_unlock(&GlobalMid_Lock);
6492 } else
6493 rc = -ENOMEM;
6494 }
6495 cifs_buf_release(pSMB);
6496 return rc;
6497}
6498#endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linux kernel - Deliverables
This page took 0.738478 seconds and 5 git commands to generate.