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