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