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