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