4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Contains the routines for constructing the SMB PDUs themselves
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.
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.
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
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 */
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 */
31 #include <linux/kernel.h>
32 #include <linux/vfs.h>
33 #include <linux/slab.h>
34 #include <linux/posix_acl_xattr.h>
35 #include <linux/pagemap.h>
36 #include <linux/swap.h>
37 #include <linux/task_io_accounting_ops.h>
38 #include <asm/uaccess.h>
42 #include "cifsproto.h"
43 #include "cifs_unicode.h"
44 #include "cifs_debug.h"
47 #ifdef CONFIG_CIFS_POSIX
52 #ifdef CONFIG_CIFS_WEAK_PW_HASH
53 {LANMAN_PROT
, "\2LM1.2X002"},
54 {LANMAN2_PROT
, "\2LANMAN2.1"},
55 #endif /* weak password hashing for legacy clients */
56 {CIFS_PROT
, "\2NT LM 0.12"},
57 {POSIX_PROT
, "\2POSIX 2"},
65 #ifdef CONFIG_CIFS_WEAK_PW_HASH
66 {LANMAN_PROT
, "\2LM1.2X002"},
67 {LANMAN2_PROT
, "\2LANMAN2.1"},
68 #endif /* weak password hashing for legacy clients */
69 {CIFS_PROT
, "\2NT LM 0.12"},
74 /* define the number of elements in the cifs dialect array */
75 #ifdef CONFIG_CIFS_POSIX
76 #ifdef CONFIG_CIFS_WEAK_PW_HASH
77 #define CIFS_NUM_PROT 4
79 #define CIFS_NUM_PROT 2
80 #endif /* CIFS_WEAK_PW_HASH */
82 #ifdef CONFIG_CIFS_WEAK_PW_HASH
83 #define CIFS_NUM_PROT 3
85 #define CIFS_NUM_PROT 1
86 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
87 #endif /* CIFS_POSIX */
90 * Mark as invalid, all open files on tree connections since they
91 * were closed when session to server was lost.
94 cifs_mark_open_files_invalid(struct cifs_tcon
*tcon
)
96 struct cifsFileInfo
*open_file
= NULL
;
97 struct list_head
*tmp
;
98 struct list_head
*tmp1
;
100 /* list all files open on tree connection and mark them invalid */
101 spin_lock(&cifs_file_list_lock
);
102 list_for_each_safe(tmp
, tmp1
, &tcon
->openFileList
) {
103 open_file
= list_entry(tmp
, struct cifsFileInfo
, tlist
);
104 open_file
->invalidHandle
= true;
105 open_file
->oplock_break_cancelled
= true;
107 spin_unlock(&cifs_file_list_lock
);
109 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
114 /* reconnect the socket, tcon, and smb session if needed */
116 cifs_reconnect_tcon(struct cifs_tcon
*tcon
, int smb_command
)
119 struct cifs_ses
*ses
;
120 struct TCP_Server_Info
*server
;
121 struct nls_table
*nls_codepage
;
124 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
125 * tcp and smb session status done differently for those three - in the
132 server
= ses
->server
;
135 * only tree disconnect, open, and write, (and ulogoff which does not
136 * have tcon) are allowed as we start force umount
138 if (tcon
->tidStatus
== CifsExiting
) {
139 if (smb_command
!= SMB_COM_WRITE_ANDX
&&
140 smb_command
!= SMB_COM_OPEN_ANDX
&&
141 smb_command
!= SMB_COM_TREE_DISCONNECT
) {
142 cifs_dbg(FYI
, "can not send cmd %d while umounting\n",
149 * Give demultiplex thread up to 10 seconds to reconnect, should be
150 * greater than cifs socket timeout which is 7 seconds
152 while (server
->tcpStatus
== CifsNeedReconnect
) {
153 wait_event_interruptible_timeout(server
->response_q
,
154 (server
->tcpStatus
!= CifsNeedReconnect
), 10 * HZ
);
156 /* are we still trying to reconnect? */
157 if (server
->tcpStatus
!= CifsNeedReconnect
)
161 * on "soft" mounts we wait once. Hard mounts keep
162 * retrying until process is killed or server comes
166 cifs_dbg(FYI
, "gave up waiting on reconnect in smb_init\n");
171 if (!ses
->need_reconnect
&& !tcon
->need_reconnect
)
174 nls_codepage
= load_nls_default();
177 * need to prevent multiple threads trying to simultaneously
178 * reconnect the same SMB session
180 mutex_lock(&ses
->session_mutex
);
181 rc
= cifs_negotiate_protocol(0, ses
);
182 if (rc
== 0 && ses
->need_reconnect
)
183 rc
= cifs_setup_session(0, ses
, nls_codepage
);
185 /* do we need to reconnect tcon? */
186 if (rc
|| !tcon
->need_reconnect
) {
187 mutex_unlock(&ses
->session_mutex
);
191 cifs_mark_open_files_invalid(tcon
);
192 rc
= CIFSTCon(0, ses
, tcon
->treeName
, tcon
, nls_codepage
);
193 mutex_unlock(&ses
->session_mutex
);
194 cifs_dbg(FYI
, "reconnect tcon rc = %d\n", rc
);
200 * FIXME: check if wsize needs updated due to negotiated smb buffer
203 atomic_inc(&tconInfoReconnectCount
);
205 /* tell server Unix caps we support */
206 if (ses
->capabilities
& CAP_UNIX
)
207 reset_cifs_unix_caps(0, tcon
, NULL
, NULL
);
210 * Removed call to reopen open files here. It is safer (and faster) to
211 * reopen files one at a time as needed in read and write.
213 * FIXME: what about file locks? don't we need to reclaim them ASAP?
218 * Check if handle based operation so we know whether we can continue
219 * or not without returning to caller to reset file handle
221 switch (smb_command
) {
222 case SMB_COM_READ_ANDX
:
223 case SMB_COM_WRITE_ANDX
:
225 case SMB_COM_FIND_CLOSE2
:
226 case SMB_COM_LOCKING_ANDX
:
230 unload_nls(nls_codepage
);
234 /* Allocate and return pointer to an SMB request buffer, and set basic
235 SMB information in the SMB header. If the return code is zero, this
236 function must have filled in request_buf pointer */
238 small_smb_init(int smb_command
, int wct
, struct cifs_tcon
*tcon
,
243 rc
= cifs_reconnect_tcon(tcon
, smb_command
);
247 *request_buf
= cifs_small_buf_get();
248 if (*request_buf
== NULL
) {
249 /* BB should we add a retry in here if not a writepage? */
253 header_assemble((struct smb_hdr
*) *request_buf
, smb_command
,
257 cifs_stats_inc(&tcon
->num_smbs_sent
);
263 small_smb_init_no_tc(const int smb_command
, const int wct
,
264 struct cifs_ses
*ses
, void **request_buf
)
267 struct smb_hdr
*buffer
;
269 rc
= small_smb_init(smb_command
, wct
, NULL
, request_buf
);
273 buffer
= (struct smb_hdr
*)*request_buf
;
274 buffer
->Mid
= get_next_mid(ses
->server
);
275 if (ses
->capabilities
& CAP_UNICODE
)
276 buffer
->Flags2
|= SMBFLG2_UNICODE
;
277 if (ses
->capabilities
& CAP_STATUS32
)
278 buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
280 /* uid, tid can stay at zero as set in header assemble */
282 /* BB add support for turning on the signing when
283 this function is used after 1st of session setup requests */
288 /* If the return code is zero, this function must fill in request_buf pointer */
290 __smb_init(int smb_command
, int wct
, struct cifs_tcon
*tcon
,
291 void **request_buf
, void **response_buf
)
293 *request_buf
= cifs_buf_get();
294 if (*request_buf
== NULL
) {
295 /* BB should we add a retry in here if not a writepage? */
298 /* Although the original thought was we needed the response buf for */
299 /* potential retries of smb operations it turns out we can determine */
300 /* from the mid flags when the request buffer can be resent without */
301 /* having to use a second distinct buffer for the response */
303 *response_buf
= *request_buf
;
305 header_assemble((struct smb_hdr
*) *request_buf
, smb_command
, tcon
,
309 cifs_stats_inc(&tcon
->num_smbs_sent
);
314 /* If the return code is zero, this function must fill in request_buf pointer */
316 smb_init(int smb_command
, int wct
, struct cifs_tcon
*tcon
,
317 void **request_buf
, void **response_buf
)
321 rc
= cifs_reconnect_tcon(tcon
, smb_command
);
325 return __smb_init(smb_command
, wct
, tcon
, request_buf
, response_buf
);
329 smb_init_no_reconnect(int smb_command
, int wct
, struct cifs_tcon
*tcon
,
330 void **request_buf
, void **response_buf
)
332 if (tcon
->ses
->need_reconnect
|| tcon
->need_reconnect
)
335 return __smb_init(smb_command
, wct
, tcon
, request_buf
, response_buf
);
338 static int validate_t2(struct smb_t2_rsp
*pSMB
)
340 unsigned int total_size
;
342 /* check for plausible wct */
343 if (pSMB
->hdr
.WordCount
< 10)
346 /* check for parm and data offset going beyond end of smb */
347 if (get_unaligned_le16(&pSMB
->t2_rsp
.ParameterOffset
) > 1024 ||
348 get_unaligned_le16(&pSMB
->t2_rsp
.DataOffset
) > 1024)
351 total_size
= get_unaligned_le16(&pSMB
->t2_rsp
.ParameterCount
);
352 if (total_size
>= 512)
355 /* check that bcc is at least as big as parms + data, and that it is
356 * less than negotiated smb buffer
358 total_size
+= get_unaligned_le16(&pSMB
->t2_rsp
.DataCount
);
359 if (total_size
> get_bcc(&pSMB
->hdr
) ||
360 total_size
>= CIFSMaxBufSize
+ MAX_CIFS_HDR_SIZE
)
365 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB
,
366 sizeof(struct smb_t2_rsp
) + 16);
371 decode_ext_sec_blob(struct cifs_ses
*ses
, NEGOTIATE_RSP
*pSMBr
)
375 char *guid
= pSMBr
->u
.extended_response
.GUID
;
376 struct TCP_Server_Info
*server
= ses
->server
;
378 count
= get_bcc(&pSMBr
->hdr
);
379 if (count
< SMB1_CLIENT_GUID_SIZE
)
382 spin_lock(&cifs_tcp_ses_lock
);
383 if (server
->srv_count
> 1) {
384 spin_unlock(&cifs_tcp_ses_lock
);
385 if (memcmp(server
->server_GUID
, guid
, SMB1_CLIENT_GUID_SIZE
) != 0) {
386 cifs_dbg(FYI
, "server UID changed\n");
387 memcpy(server
->server_GUID
, guid
, SMB1_CLIENT_GUID_SIZE
);
390 spin_unlock(&cifs_tcp_ses_lock
);
391 memcpy(server
->server_GUID
, guid
, SMB1_CLIENT_GUID_SIZE
);
394 if (count
== SMB1_CLIENT_GUID_SIZE
) {
395 server
->sec_ntlmssp
= true;
397 count
-= SMB1_CLIENT_GUID_SIZE
;
398 rc
= decode_negTokenInit(
399 pSMBr
->u
.extended_response
.SecurityBlob
, count
, server
);
408 cifs_enable_signing(struct TCP_Server_Info
*server
, bool mnt_sign_required
)
410 bool srv_sign_required
= server
->sec_mode
& server
->vals
->signing_required
;
411 bool srv_sign_enabled
= server
->sec_mode
& server
->vals
->signing_enabled
;
412 bool mnt_sign_enabled
= global_secflags
& CIFSSEC_MAY_SIGN
;
415 * Is signing required by mnt options? If not then check
416 * global_secflags to see if it is there.
418 if (!mnt_sign_required
)
419 mnt_sign_required
= ((global_secflags
& CIFSSEC_MUST_SIGN
) ==
423 * If signing is required then it's automatically enabled too,
424 * otherwise, check to see if the secflags allow it.
426 mnt_sign_enabled
= mnt_sign_required
? mnt_sign_required
:
427 (global_secflags
& CIFSSEC_MAY_SIGN
);
429 /* If server requires signing, does client allow it? */
430 if (srv_sign_required
) {
431 if (!mnt_sign_enabled
) {
432 cifs_dbg(VFS
, "Server requires signing, but it's disabled in SecurityFlags!");
438 /* If client requires signing, does server allow it? */
439 if (mnt_sign_required
) {
440 if (!srv_sign_enabled
) {
441 cifs_dbg(VFS
, "Server does not support signing!");
450 #ifdef CONFIG_CIFS_WEAK_PW_HASH
452 decode_lanman_negprot_rsp(struct TCP_Server_Info
*server
, NEGOTIATE_RSP
*pSMBr
)
455 struct lanman_neg_rsp
*rsp
= (struct lanman_neg_rsp
*)pSMBr
;
457 if (server
->dialect
!= LANMAN_PROT
&& server
->dialect
!= LANMAN2_PROT
)
460 server
->sec_mode
= le16_to_cpu(rsp
->SecurityMode
);
461 server
->maxReq
= min_t(unsigned int,
462 le16_to_cpu(rsp
->MaxMpxCount
),
464 set_credits(server
, server
->maxReq
);
465 server
->maxBuf
= le16_to_cpu(rsp
->MaxBufSize
);
466 /* even though we do not use raw we might as well set this
467 accurately, in case we ever find a need for it */
468 if ((le16_to_cpu(rsp
->RawMode
) & RAW_ENABLE
) == RAW_ENABLE
) {
469 server
->max_rw
= 0xFF00;
470 server
->capabilities
= CAP_MPX_MODE
| CAP_RAW_MODE
;
472 server
->max_rw
= 0;/* do not need to use raw anyway */
473 server
->capabilities
= CAP_MPX_MODE
;
475 tmp
= (__s16
)le16_to_cpu(rsp
->ServerTimeZone
);
477 /* OS/2 often does not set timezone therefore
478 * we must use server time to calc time zone.
479 * Could deviate slightly from the right zone.
480 * Smallest defined timezone difference is 15 minutes
481 * (i.e. Nepal). Rounding up/down is done to match
484 int val
, seconds
, remain
, result
;
485 struct timespec ts
, utc
;
487 ts
= cnvrtDosUnixTm(rsp
->SrvTime
.Date
,
488 rsp
->SrvTime
.Time
, 0);
489 cifs_dbg(FYI
, "SrvTime %d sec since 1970 (utc: %d) diff: %d\n",
490 (int)ts
.tv_sec
, (int)utc
.tv_sec
,
491 (int)(utc
.tv_sec
- ts
.tv_sec
));
492 val
= (int)(utc
.tv_sec
- ts
.tv_sec
);
494 result
= (seconds
/ MIN_TZ_ADJ
) * MIN_TZ_ADJ
;
495 remain
= seconds
% MIN_TZ_ADJ
;
496 if (remain
>= (MIN_TZ_ADJ
/ 2))
497 result
+= MIN_TZ_ADJ
;
500 server
->timeAdj
= result
;
502 server
->timeAdj
= (int)tmp
;
503 server
->timeAdj
*= 60; /* also in seconds */
505 cifs_dbg(FYI
, "server->timeAdj: %d seconds\n", server
->timeAdj
);
508 /* BB get server time for time conversions and add
509 code to use it and timezone since this is not UTC */
511 if (rsp
->EncryptionKeyLength
==
512 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE
)) {
513 memcpy(server
->cryptkey
, rsp
->EncryptionKey
,
514 CIFS_CRYPTO_KEY_SIZE
);
515 } else if (server
->sec_mode
& SECMODE_PW_ENCRYPT
) {
516 return -EIO
; /* need cryptkey unless plain text */
519 cifs_dbg(FYI
, "LANMAN negotiated\n");
524 decode_lanman_negprot_rsp(struct TCP_Server_Info
*server
, NEGOTIATE_RSP
*pSMBr
)
526 cifs_dbg(VFS
, "mount failed, cifs module not built with CIFS_WEAK_PW_HASH support\n");
532 should_set_ext_sec_flag(enum securityEnum sectype
)
539 if (global_secflags
&
540 (CIFSSEC_MAY_KRB5
| CIFSSEC_MAY_NTLMSSP
))
549 CIFSSMBNegotiate(const unsigned int xid
, struct cifs_ses
*ses
)
552 NEGOTIATE_RSP
*pSMBr
;
556 struct TCP_Server_Info
*server
= ses
->server
;
560 WARN(1, "%s: server is NULL!\n", __func__
);
564 rc
= smb_init(SMB_COM_NEGOTIATE
, 0, NULL
/* no tcon yet */ ,
565 (void **) &pSMB
, (void **) &pSMBr
);
569 pSMB
->hdr
.Mid
= get_next_mid(server
);
570 pSMB
->hdr
.Flags2
|= (SMBFLG2_UNICODE
| SMBFLG2_ERR_STATUS
);
572 if (should_set_ext_sec_flag(ses
->sectype
)) {
573 cifs_dbg(FYI
, "Requesting extended security.");
574 pSMB
->hdr
.Flags2
|= SMBFLG2_EXT_SEC
;
578 for (i
= 0; i
< CIFS_NUM_PROT
; i
++) {
579 strncpy(pSMB
->DialectsArray
+count
, protocols
[i
].name
, 16);
580 count
+= strlen(protocols
[i
].name
) + 1;
581 /* null at end of source and target buffers anyway */
583 inc_rfc1001_len(pSMB
, count
);
584 pSMB
->ByteCount
= cpu_to_le16(count
);
586 rc
= SendReceive(xid
, ses
, (struct smb_hdr
*) pSMB
,
587 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
591 server
->dialect
= le16_to_cpu(pSMBr
->DialectIndex
);
592 cifs_dbg(FYI
, "Dialect: %d\n", server
->dialect
);
593 /* Check wct = 1 error case */
594 if ((pSMBr
->hdr
.WordCount
< 13) || (server
->dialect
== BAD_PROT
)) {
595 /* core returns wct = 1, but we do not ask for core - otherwise
596 small wct just comes when dialect index is -1 indicating we
597 could not negotiate a common dialect */
600 } else if (pSMBr
->hdr
.WordCount
== 13) {
601 server
->negflavor
= CIFS_NEGFLAVOR_LANMAN
;
602 rc
= decode_lanman_negprot_rsp(server
, pSMBr
);
604 } else if (pSMBr
->hdr
.WordCount
!= 17) {
609 /* else wct == 17, NTLM or better */
611 server
->sec_mode
= pSMBr
->SecurityMode
;
612 if ((server
->sec_mode
& SECMODE_USER
) == 0)
613 cifs_dbg(FYI
, "share mode security\n");
615 /* one byte, so no need to convert this or EncryptionKeyLen from
617 server
->maxReq
= min_t(unsigned int, le16_to_cpu(pSMBr
->MaxMpxCount
),
619 set_credits(server
, server
->maxReq
);
620 /* probably no need to store and check maxvcs */
621 server
->maxBuf
= le32_to_cpu(pSMBr
->MaxBufferSize
);
622 server
->max_rw
= le32_to_cpu(pSMBr
->MaxRawSize
);
623 cifs_dbg(NOISY
, "Max buf = %d\n", ses
->server
->maxBuf
);
624 server
->capabilities
= le32_to_cpu(pSMBr
->Capabilities
);
625 server
->timeAdj
= (int)(__s16
)le16_to_cpu(pSMBr
->ServerTimeZone
);
626 server
->timeAdj
*= 60;
628 if (pSMBr
->EncryptionKeyLength
== CIFS_CRYPTO_KEY_SIZE
) {
629 server
->negflavor
= CIFS_NEGFLAVOR_UNENCAP
;
630 memcpy(ses
->server
->cryptkey
, pSMBr
->u
.EncryptionKey
,
631 CIFS_CRYPTO_KEY_SIZE
);
632 } else if ((pSMBr
->hdr
.Flags2
& SMBFLG2_EXT_SEC
||
633 server
->capabilities
& CAP_EXTENDED_SECURITY
) &&
634 (pSMBr
->EncryptionKeyLength
== 0)) {
635 server
->negflavor
= CIFS_NEGFLAVOR_EXTENDED
;
636 rc
= decode_ext_sec_blob(ses
, pSMBr
);
637 } else if (server
->sec_mode
& SECMODE_PW_ENCRYPT
) {
638 rc
= -EIO
; /* no crypt key only if plain text pwd */
640 server
->negflavor
= CIFS_NEGFLAVOR_UNENCAP
;
641 server
->capabilities
&= ~CAP_EXTENDED_SECURITY
;
646 rc
= cifs_enable_signing(server
, ses
->sign
);
648 cifs_buf_release(pSMB
);
650 cifs_dbg(FYI
, "negprot rc %d\n", rc
);
655 CIFSSMBTDis(const unsigned int xid
, struct cifs_tcon
*tcon
)
657 struct smb_hdr
*smb_buffer
;
660 cifs_dbg(FYI
, "In tree disconnect\n");
662 /* BB: do we need to check this? These should never be NULL. */
663 if ((tcon
->ses
== NULL
) || (tcon
->ses
->server
== NULL
))
667 * No need to return error on this operation if tid invalidated and
668 * closed on server already e.g. due to tcp session crashing. Also,
669 * the tcon is no longer on the list, so no need to take lock before
672 if ((tcon
->need_reconnect
) || (tcon
->ses
->need_reconnect
))
675 rc
= small_smb_init(SMB_COM_TREE_DISCONNECT
, 0, tcon
,
676 (void **)&smb_buffer
);
680 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *)smb_buffer
, 0);
682 cifs_dbg(FYI
, "Tree disconnect failed %d\n", rc
);
684 /* No need to return error on this operation if tid invalidated and
685 closed on server already e.g. due to tcp session crashing */
693 * This is a no-op for now. We're not really interested in the reply, but
694 * rather in the fact that the server sent one and that server->lstrp
697 * FIXME: maybe we should consider checking that the reply matches request?
700 cifs_echo_callback(struct mid_q_entry
*mid
)
702 struct TCP_Server_Info
*server
= mid
->callback_data
;
704 DeleteMidQEntry(mid
);
705 add_credits(server
, 1, CIFS_ECHO_OP
);
709 CIFSSMBEcho(struct TCP_Server_Info
*server
)
714 struct smb_rqst rqst
= { .rq_iov
= &iov
,
717 cifs_dbg(FYI
, "In echo request\n");
719 rc
= small_smb_init(SMB_COM_ECHO
, 0, NULL
, (void **)&smb
);
723 /* set up echo request */
724 smb
->hdr
.Tid
= 0xffff;
725 smb
->hdr
.WordCount
= 1;
726 put_unaligned_le16(1, &smb
->EchoCount
);
727 put_bcc(1, &smb
->hdr
);
729 inc_rfc1001_len(smb
, 3);
731 iov
.iov_len
= be32_to_cpu(smb
->hdr
.smb_buf_length
) + 4;
733 rc
= cifs_call_async(server
, &rqst
, NULL
, cifs_echo_callback
,
734 server
, CIFS_ASYNC_OP
| CIFS_ECHO_OP
);
736 cifs_dbg(FYI
, "Echo request failed: %d\n", rc
);
738 cifs_small_buf_release(smb
);
744 CIFSSMBLogoff(const unsigned int xid
, struct cifs_ses
*ses
)
746 LOGOFF_ANDX_REQ
*pSMB
;
749 cifs_dbg(FYI
, "In SMBLogoff for session disconnect\n");
752 * BB: do we need to check validity of ses and server? They should
753 * always be valid since we have an active reference. If not, that
754 * should probably be a BUG()
756 if (!ses
|| !ses
->server
)
759 mutex_lock(&ses
->session_mutex
);
760 if (ses
->need_reconnect
)
761 goto session_already_dead
; /* no need to send SMBlogoff if uid
762 already closed due to reconnect */
763 rc
= small_smb_init(SMB_COM_LOGOFF_ANDX
, 2, NULL
, (void **)&pSMB
);
765 mutex_unlock(&ses
->session_mutex
);
769 pSMB
->hdr
.Mid
= get_next_mid(ses
->server
);
771 if (ses
->server
->sign
)
772 pSMB
->hdr
.Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
774 pSMB
->hdr
.Uid
= ses
->Suid
;
776 pSMB
->AndXCommand
= 0xFF;
777 rc
= SendReceiveNoRsp(xid
, ses
, (char *) pSMB
, 0);
778 session_already_dead
:
779 mutex_unlock(&ses
->session_mutex
);
781 /* if session dead then we do not need to do ulogoff,
782 since server closed smb session, no sense reporting
790 CIFSPOSIXDelFile(const unsigned int xid
, struct cifs_tcon
*tcon
,
791 const char *fileName
, __u16 type
,
792 const struct nls_table
*nls_codepage
, int remap
)
794 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
795 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
796 struct unlink_psx_rq
*pRqD
;
799 int bytes_returned
= 0;
800 __u16 params
, param_offset
, offset
, byte_count
;
802 cifs_dbg(FYI
, "In POSIX delete\n");
804 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
809 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
811 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, fileName
,
812 PATH_MAX
, nls_codepage
, remap
);
813 name_len
++; /* trailing null */
815 } else { /* BB add path length overrun check */
816 name_len
= strnlen(fileName
, PATH_MAX
);
817 name_len
++; /* trailing null */
818 strncpy(pSMB
->FileName
, fileName
, name_len
);
821 params
= 6 + name_len
;
822 pSMB
->MaxParameterCount
= cpu_to_le16(2);
823 pSMB
->MaxDataCount
= 0; /* BB double check this with jra */
824 pSMB
->MaxSetupCount
= 0;
829 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
830 InformationLevel
) - 4;
831 offset
= param_offset
+ params
;
833 /* Setup pointer to Request Data (inode type) */
834 pRqD
= (struct unlink_psx_rq
*)(((char *)&pSMB
->hdr
.Protocol
) + offset
);
835 pRqD
->type
= cpu_to_le16(type
);
836 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
837 pSMB
->DataOffset
= cpu_to_le16(offset
);
838 pSMB
->SetupCount
= 1;
840 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
841 byte_count
= 3 /* pad */ + params
+ sizeof(struct unlink_psx_rq
);
843 pSMB
->DataCount
= cpu_to_le16(sizeof(struct unlink_psx_rq
));
844 pSMB
->TotalDataCount
= cpu_to_le16(sizeof(struct unlink_psx_rq
));
845 pSMB
->ParameterCount
= cpu_to_le16(params
);
846 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
847 pSMB
->InformationLevel
= cpu_to_le16(SMB_POSIX_UNLINK
);
849 inc_rfc1001_len(pSMB
, byte_count
);
850 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
851 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
852 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
854 cifs_dbg(FYI
, "Posix delete returned %d\n", rc
);
855 cifs_buf_release(pSMB
);
857 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_deletes
);
866 CIFSSMBDelFile(const unsigned int xid
, struct cifs_tcon
*tcon
, const char *name
,
867 struct cifs_sb_info
*cifs_sb
)
869 DELETE_FILE_REQ
*pSMB
= NULL
;
870 DELETE_FILE_RSP
*pSMBr
= NULL
;
874 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
877 rc
= smb_init(SMB_COM_DELETE
, 1, tcon
, (void **) &pSMB
,
882 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
883 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->fileName
, name
,
884 PATH_MAX
, cifs_sb
->local_nls
,
886 name_len
++; /* trailing null */
888 } else { /* BB improve check for buffer overruns BB */
889 name_len
= strnlen(name
, PATH_MAX
);
890 name_len
++; /* trailing null */
891 strncpy(pSMB
->fileName
, name
, name_len
);
893 pSMB
->SearchAttributes
=
894 cpu_to_le16(ATTR_READONLY
| ATTR_HIDDEN
| ATTR_SYSTEM
);
895 pSMB
->BufferFormat
= 0x04;
896 inc_rfc1001_len(pSMB
, name_len
+ 1);
897 pSMB
->ByteCount
= cpu_to_le16(name_len
+ 1);
898 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
899 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
900 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_deletes
);
902 cifs_dbg(FYI
, "Error in RMFile = %d\n", rc
);
904 cifs_buf_release(pSMB
);
912 CIFSSMBRmDir(const unsigned int xid
, struct cifs_tcon
*tcon
, const char *name
,
913 struct cifs_sb_info
*cifs_sb
)
915 DELETE_DIRECTORY_REQ
*pSMB
= NULL
;
916 DELETE_DIRECTORY_RSP
*pSMBr
= NULL
;
920 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
922 cifs_dbg(FYI
, "In CIFSSMBRmDir\n");
924 rc
= smb_init(SMB_COM_DELETE_DIRECTORY
, 0, tcon
, (void **) &pSMB
,
929 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
930 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->DirName
, name
,
931 PATH_MAX
, cifs_sb
->local_nls
,
933 name_len
++; /* trailing null */
935 } else { /* BB improve check for buffer overruns BB */
936 name_len
= strnlen(name
, PATH_MAX
);
937 name_len
++; /* trailing null */
938 strncpy(pSMB
->DirName
, name
, name_len
);
941 pSMB
->BufferFormat
= 0x04;
942 inc_rfc1001_len(pSMB
, name_len
+ 1);
943 pSMB
->ByteCount
= cpu_to_le16(name_len
+ 1);
944 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
945 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
946 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_rmdirs
);
948 cifs_dbg(FYI
, "Error in RMDir = %d\n", rc
);
950 cifs_buf_release(pSMB
);
957 CIFSSMBMkDir(const unsigned int xid
, struct cifs_tcon
*tcon
, const char *name
,
958 struct cifs_sb_info
*cifs_sb
)
961 CREATE_DIRECTORY_REQ
*pSMB
= NULL
;
962 CREATE_DIRECTORY_RSP
*pSMBr
= NULL
;
965 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
967 cifs_dbg(FYI
, "In CIFSSMBMkDir\n");
969 rc
= smb_init(SMB_COM_CREATE_DIRECTORY
, 0, tcon
, (void **) &pSMB
,
974 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
975 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->DirName
, name
,
976 PATH_MAX
, cifs_sb
->local_nls
,
978 name_len
++; /* trailing null */
980 } else { /* BB improve check for buffer overruns BB */
981 name_len
= strnlen(name
, PATH_MAX
);
982 name_len
++; /* trailing null */
983 strncpy(pSMB
->DirName
, name
, name_len
);
986 pSMB
->BufferFormat
= 0x04;
987 inc_rfc1001_len(pSMB
, name_len
+ 1);
988 pSMB
->ByteCount
= cpu_to_le16(name_len
+ 1);
989 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
990 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
991 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_mkdirs
);
993 cifs_dbg(FYI
, "Error in Mkdir = %d\n", rc
);
995 cifs_buf_release(pSMB
);
1002 CIFSPOSIXCreate(const unsigned int xid
, struct cifs_tcon
*tcon
,
1003 __u32 posix_flags
, __u64 mode
, __u16
*netfid
,
1004 FILE_UNIX_BASIC_INFO
*pRetData
, __u32
*pOplock
,
1005 const char *name
, const struct nls_table
*nls_codepage
,
1008 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
1009 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
1012 int bytes_returned
= 0;
1013 __u16 params
, param_offset
, offset
, byte_count
, count
;
1014 OPEN_PSX_REQ
*pdata
;
1015 OPEN_PSX_RSP
*psx_rsp
;
1017 cifs_dbg(FYI
, "In POSIX Create\n");
1019 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
1024 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
1026 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, name
,
1027 PATH_MAX
, nls_codepage
, remap
);
1028 name_len
++; /* trailing null */
1030 } else { /* BB improve the check for buffer overruns BB */
1031 name_len
= strnlen(name
, PATH_MAX
);
1032 name_len
++; /* trailing null */
1033 strncpy(pSMB
->FileName
, name
, name_len
);
1036 params
= 6 + name_len
;
1037 count
= sizeof(OPEN_PSX_REQ
);
1038 pSMB
->MaxParameterCount
= cpu_to_le16(2);
1039 pSMB
->MaxDataCount
= cpu_to_le16(1000); /* large enough */
1040 pSMB
->MaxSetupCount
= 0;
1044 pSMB
->Reserved2
= 0;
1045 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
1046 InformationLevel
) - 4;
1047 offset
= param_offset
+ params
;
1048 pdata
= (OPEN_PSX_REQ
*)(((char *)&pSMB
->hdr
.Protocol
) + offset
);
1049 pdata
->Level
= cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC
);
1050 pdata
->Permissions
= cpu_to_le64(mode
);
1051 pdata
->PosixOpenFlags
= cpu_to_le32(posix_flags
);
1052 pdata
->OpenFlags
= cpu_to_le32(*pOplock
);
1053 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
1054 pSMB
->DataOffset
= cpu_to_le16(offset
);
1055 pSMB
->SetupCount
= 1;
1056 pSMB
->Reserved3
= 0;
1057 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
1058 byte_count
= 3 /* pad */ + params
+ count
;
1060 pSMB
->DataCount
= cpu_to_le16(count
);
1061 pSMB
->ParameterCount
= cpu_to_le16(params
);
1062 pSMB
->TotalDataCount
= pSMB
->DataCount
;
1063 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
1064 pSMB
->InformationLevel
= cpu_to_le16(SMB_POSIX_OPEN
);
1065 pSMB
->Reserved4
= 0;
1066 inc_rfc1001_len(pSMB
, byte_count
);
1067 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
1068 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
1069 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
1071 cifs_dbg(FYI
, "Posix create returned %d\n", rc
);
1072 goto psx_create_err
;
1075 cifs_dbg(FYI
, "copying inode info\n");
1076 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
1078 if (rc
|| get_bcc(&pSMBr
->hdr
) < sizeof(OPEN_PSX_RSP
)) {
1079 rc
= -EIO
; /* bad smb */
1080 goto psx_create_err
;
1083 /* copy return information to pRetData */
1084 psx_rsp
= (OPEN_PSX_RSP
*)((char *) &pSMBr
->hdr
.Protocol
1085 + le16_to_cpu(pSMBr
->t2
.DataOffset
));
1087 *pOplock
= le16_to_cpu(psx_rsp
->OplockFlags
);
1089 *netfid
= psx_rsp
->Fid
; /* cifs fid stays in le */
1090 /* Let caller know file was created so we can set the mode. */
1091 /* Do we care about the CreateAction in any other cases? */
1092 if (cpu_to_le32(FILE_CREATE
) == psx_rsp
->CreateAction
)
1093 *pOplock
|= CIFS_CREATE_ACTION
;
1094 /* check to make sure response data is there */
1095 if (psx_rsp
->ReturnedLevel
!= cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC
)) {
1096 pRetData
->Type
= cpu_to_le32(-1); /* unknown */
1097 cifs_dbg(NOISY
, "unknown type\n");
1099 if (get_bcc(&pSMBr
->hdr
) < sizeof(OPEN_PSX_RSP
)
1100 + sizeof(FILE_UNIX_BASIC_INFO
)) {
1101 cifs_dbg(VFS
, "Open response data too small\n");
1102 pRetData
->Type
= cpu_to_le32(-1);
1103 goto psx_create_err
;
1105 memcpy((char *) pRetData
,
1106 (char *)psx_rsp
+ sizeof(OPEN_PSX_RSP
),
1107 sizeof(FILE_UNIX_BASIC_INFO
));
1111 cifs_buf_release(pSMB
);
1113 if (posix_flags
& SMB_O_DIRECTORY
)
1114 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_posixmkdirs
);
1116 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_posixopens
);
1124 static __u16
convert_disposition(int disposition
)
1128 switch (disposition
) {
1129 case FILE_SUPERSEDE
:
1130 ofun
= SMBOPEN_OCREATE
| SMBOPEN_OTRUNC
;
1133 ofun
= SMBOPEN_OAPPEND
;
1136 ofun
= SMBOPEN_OCREATE
;
1139 ofun
= SMBOPEN_OCREATE
| SMBOPEN_OAPPEND
;
1141 case FILE_OVERWRITE
:
1142 ofun
= SMBOPEN_OTRUNC
;
1144 case FILE_OVERWRITE_IF
:
1145 ofun
= SMBOPEN_OCREATE
| SMBOPEN_OTRUNC
;
1148 cifs_dbg(FYI
, "unknown disposition %d\n", disposition
);
1149 ofun
= SMBOPEN_OAPPEND
; /* regular open */
1155 access_flags_to_smbopen_mode(const int access_flags
)
1157 int masked_flags
= access_flags
& (GENERIC_READ
| GENERIC_WRITE
);
1159 if (masked_flags
== GENERIC_READ
)
1160 return SMBOPEN_READ
;
1161 else if (masked_flags
== GENERIC_WRITE
)
1162 return SMBOPEN_WRITE
;
1164 /* just go for read/write */
1165 return SMBOPEN_READWRITE
;
1169 SMBLegacyOpen(const unsigned int xid
, struct cifs_tcon
*tcon
,
1170 const char *fileName
, const int openDisposition
,
1171 const int access_flags
, const int create_options
, __u16
*netfid
,
1172 int *pOplock
, FILE_ALL_INFO
*pfile_info
,
1173 const struct nls_table
*nls_codepage
, int remap
)
1176 OPENX_REQ
*pSMB
= NULL
;
1177 OPENX_RSP
*pSMBr
= NULL
;
1183 rc
= smb_init(SMB_COM_OPEN_ANDX
, 15, tcon
, (void **) &pSMB
,
1188 pSMB
->AndXCommand
= 0xFF; /* none */
1190 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
1191 count
= 1; /* account for one byte pad to word boundary */
1193 cifsConvertToUTF16((__le16
*) (pSMB
->fileName
+ 1),
1194 fileName
, PATH_MAX
, nls_codepage
, remap
);
1195 name_len
++; /* trailing null */
1197 } else { /* BB improve check for buffer overruns BB */
1198 count
= 0; /* no pad */
1199 name_len
= strnlen(fileName
, PATH_MAX
);
1200 name_len
++; /* trailing null */
1201 strncpy(pSMB
->fileName
, fileName
, name_len
);
1203 if (*pOplock
& REQ_OPLOCK
)
1204 pSMB
->OpenFlags
= cpu_to_le16(REQ_OPLOCK
);
1205 else if (*pOplock
& REQ_BATCHOPLOCK
)
1206 pSMB
->OpenFlags
= cpu_to_le16(REQ_BATCHOPLOCK
);
1208 pSMB
->OpenFlags
|= cpu_to_le16(REQ_MORE_INFO
);
1209 pSMB
->Mode
= cpu_to_le16(access_flags_to_smbopen_mode(access_flags
));
1210 pSMB
->Mode
|= cpu_to_le16(0x40); /* deny none */
1211 /* set file as system file if special file such
1212 as fifo and server expecting SFU style and
1213 no Unix extensions */
1215 if (create_options
& CREATE_OPTION_SPECIAL
)
1216 pSMB
->FileAttributes
= cpu_to_le16(ATTR_SYSTEM
);
1217 else /* BB FIXME BB */
1218 pSMB
->FileAttributes
= cpu_to_le16(0/*ATTR_NORMAL*/);
1220 if (create_options
& CREATE_OPTION_READONLY
)
1221 pSMB
->FileAttributes
|= cpu_to_le16(ATTR_READONLY
);
1224 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1225 CREATE_OPTIONS_MASK); */
1226 /* BB FIXME END BB */
1228 pSMB
->Sattr
= cpu_to_le16(ATTR_HIDDEN
| ATTR_SYSTEM
| ATTR_DIRECTORY
);
1229 pSMB
->OpenFunction
= cpu_to_le16(convert_disposition(openDisposition
));
1231 inc_rfc1001_len(pSMB
, count
);
1233 pSMB
->ByteCount
= cpu_to_le16(count
);
1234 /* long_op set to 1 to allow for oplock break timeouts */
1235 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
1236 (struct smb_hdr
*)pSMBr
, &bytes_returned
, 0);
1237 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_opens
);
1239 cifs_dbg(FYI
, "Error in Open = %d\n", rc
);
1241 /* BB verify if wct == 15 */
1243 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1245 *netfid
= pSMBr
->Fid
; /* cifs fid stays in le */
1246 /* Let caller know file was created so we can set the mode. */
1247 /* Do we care about the CreateAction in any other cases? */
1249 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1250 *pOplock |= CIFS_CREATE_ACTION; */
1254 pfile_info
->CreationTime
= 0; /* BB convert CreateTime*/
1255 pfile_info
->LastAccessTime
= 0; /* BB fixme */
1256 pfile_info
->LastWriteTime
= 0; /* BB fixme */
1257 pfile_info
->ChangeTime
= 0; /* BB fixme */
1258 pfile_info
->Attributes
=
1259 cpu_to_le32(le16_to_cpu(pSMBr
->FileAttributes
));
1260 /* the file_info buf is endian converted by caller */
1261 pfile_info
->AllocationSize
=
1262 cpu_to_le64(le32_to_cpu(pSMBr
->EndOfFile
));
1263 pfile_info
->EndOfFile
= pfile_info
->AllocationSize
;
1264 pfile_info
->NumberOfLinks
= cpu_to_le32(1);
1265 pfile_info
->DeletePending
= 0;
1269 cifs_buf_release(pSMB
);
1276 CIFSSMBOpen(const unsigned int xid
, struct cifs_tcon
*tcon
,
1277 const char *fileName
, const int openDisposition
,
1278 const int access_flags
, const int create_options
, __u16
*netfid
,
1279 int *pOplock
, FILE_ALL_INFO
*pfile_info
,
1280 const struct nls_table
*nls_codepage
, int remap
)
1283 OPEN_REQ
*pSMB
= NULL
;
1284 OPEN_RSP
*pSMBr
= NULL
;
1290 rc
= smb_init(SMB_COM_NT_CREATE_ANDX
, 24, tcon
, (void **) &pSMB
,
1295 pSMB
->AndXCommand
= 0xFF; /* none */
1297 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
1298 count
= 1; /* account for one byte pad to word boundary */
1300 cifsConvertToUTF16((__le16
*) (pSMB
->fileName
+ 1),
1301 fileName
, PATH_MAX
, nls_codepage
, remap
);
1302 name_len
++; /* trailing null */
1304 pSMB
->NameLength
= cpu_to_le16(name_len
);
1305 } else { /* BB improve check for buffer overruns BB */
1306 count
= 0; /* no pad */
1307 name_len
= strnlen(fileName
, PATH_MAX
);
1308 name_len
++; /* trailing null */
1309 pSMB
->NameLength
= cpu_to_le16(name_len
);
1310 strncpy(pSMB
->fileName
, fileName
, name_len
);
1312 if (*pOplock
& REQ_OPLOCK
)
1313 pSMB
->OpenFlags
= cpu_to_le32(REQ_OPLOCK
);
1314 else if (*pOplock
& REQ_BATCHOPLOCK
)
1315 pSMB
->OpenFlags
= cpu_to_le32(REQ_BATCHOPLOCK
);
1316 pSMB
->DesiredAccess
= cpu_to_le32(access_flags
);
1317 pSMB
->AllocationSize
= 0;
1318 /* set file as system file if special file such
1319 as fifo and server expecting SFU style and
1320 no Unix extensions */
1321 if (create_options
& CREATE_OPTION_SPECIAL
)
1322 pSMB
->FileAttributes
= cpu_to_le32(ATTR_SYSTEM
);
1324 pSMB
->FileAttributes
= cpu_to_le32(ATTR_NORMAL
);
1326 /* XP does not handle ATTR_POSIX_SEMANTICS */
1327 /* but it helps speed up case sensitive checks for other
1328 servers such as Samba */
1329 if (tcon
->ses
->capabilities
& CAP_UNIX
)
1330 pSMB
->FileAttributes
|= cpu_to_le32(ATTR_POSIX_SEMANTICS
);
1332 if (create_options
& CREATE_OPTION_READONLY
)
1333 pSMB
->FileAttributes
|= cpu_to_le32(ATTR_READONLY
);
1335 pSMB
->ShareAccess
= cpu_to_le32(FILE_SHARE_ALL
);
1336 pSMB
->CreateDisposition
= cpu_to_le32(openDisposition
);
1337 pSMB
->CreateOptions
= cpu_to_le32(create_options
& CREATE_OPTIONS_MASK
);
1338 /* BB Expirement with various impersonation levels and verify */
1339 pSMB
->ImpersonationLevel
= cpu_to_le32(SECURITY_IMPERSONATION
);
1340 pSMB
->SecurityFlags
=
1341 SECURITY_CONTEXT_TRACKING
| SECURITY_EFFECTIVE_ONLY
;
1344 inc_rfc1001_len(pSMB
, count
);
1346 pSMB
->ByteCount
= cpu_to_le16(count
);
1347 /* long_op set to 1 to allow for oplock break timeouts */
1348 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
1349 (struct smb_hdr
*)pSMBr
, &bytes_returned
, 0);
1350 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_opens
);
1352 cifs_dbg(FYI
, "Error in Open = %d\n", rc
);
1354 *pOplock
= pSMBr
->OplockLevel
; /* 1 byte no need to le_to_cpu */
1355 *netfid
= pSMBr
->Fid
; /* cifs fid stays in le */
1356 /* Let caller know file was created so we can set the mode. */
1357 /* Do we care about the CreateAction in any other cases? */
1358 if (cpu_to_le32(FILE_CREATE
) == pSMBr
->CreateAction
)
1359 *pOplock
|= CIFS_CREATE_ACTION
;
1361 memcpy((char *)pfile_info
, (char *)&pSMBr
->CreationTime
,
1362 36 /* CreationTime to Attributes */);
1363 /* the file_info buf is endian converted by caller */
1364 pfile_info
->AllocationSize
= pSMBr
->AllocationSize
;
1365 pfile_info
->EndOfFile
= pSMBr
->EndOfFile
;
1366 pfile_info
->NumberOfLinks
= cpu_to_le32(1);
1367 pfile_info
->DeletePending
= 0;
1371 cifs_buf_release(pSMB
);
1378 * Discard any remaining data in the current SMB. To do this, we borrow the
1382 cifs_readv_discard(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
1384 unsigned int rfclen
= get_rfc1002_length(server
->smallbuf
);
1385 int remaining
= rfclen
+ 4 - server
->total_read
;
1386 struct cifs_readdata
*rdata
= mid
->callback_data
;
1388 while (remaining
> 0) {
1391 length
= cifs_read_from_socket(server
, server
->bigbuf
,
1392 min_t(unsigned int, remaining
,
1393 CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
)));
1396 server
->total_read
+= length
;
1397 remaining
-= length
;
1400 dequeue_mid(mid
, rdata
->result
);
1405 cifs_readv_receive(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
1408 unsigned int data_offset
, data_len
;
1409 struct cifs_readdata
*rdata
= mid
->callback_data
;
1410 char *buf
= server
->smallbuf
;
1411 unsigned int buflen
= get_rfc1002_length(buf
) + 4;
1413 cifs_dbg(FYI
, "%s: mid=%llu offset=%llu bytes=%u\n",
1414 __func__
, mid
->mid
, rdata
->offset
, rdata
->bytes
);
1417 * read the rest of READ_RSP header (sans Data array), or whatever we
1418 * can if there's not enough data. At this point, we've read down to
1421 len
= min_t(unsigned int, buflen
, server
->vals
->read_rsp_size
) -
1422 HEADER_SIZE(server
) + 1;
1424 rdata
->iov
.iov_base
= buf
+ HEADER_SIZE(server
) - 1;
1425 rdata
->iov
.iov_len
= len
;
1427 length
= cifs_readv_from_socket(server
, &rdata
->iov
, 1, len
);
1430 server
->total_read
+= length
;
1432 /* Was the SMB read successful? */
1433 rdata
->result
= server
->ops
->map_error(buf
, false);
1434 if (rdata
->result
!= 0) {
1435 cifs_dbg(FYI
, "%s: server returned error %d\n",
1436 __func__
, rdata
->result
);
1437 return cifs_readv_discard(server
, mid
);
1440 /* Is there enough to get to the rest of the READ_RSP header? */
1441 if (server
->total_read
< server
->vals
->read_rsp_size
) {
1442 cifs_dbg(FYI
, "%s: server returned short header. got=%u expected=%zu\n",
1443 __func__
, server
->total_read
,
1444 server
->vals
->read_rsp_size
);
1445 rdata
->result
= -EIO
;
1446 return cifs_readv_discard(server
, mid
);
1449 data_offset
= server
->ops
->read_data_offset(buf
) + 4;
1450 if (data_offset
< server
->total_read
) {
1452 * win2k8 sometimes sends an offset of 0 when the read
1453 * is beyond the EOF. Treat it as if the data starts just after
1456 cifs_dbg(FYI
, "%s: data offset (%u) inside read response header\n",
1457 __func__
, data_offset
);
1458 data_offset
= server
->total_read
;
1459 } else if (data_offset
> MAX_CIFS_SMALL_BUFFER_SIZE
) {
1460 /* data_offset is beyond the end of smallbuf */
1461 cifs_dbg(FYI
, "%s: data offset (%u) beyond end of smallbuf\n",
1462 __func__
, data_offset
);
1463 rdata
->result
= -EIO
;
1464 return cifs_readv_discard(server
, mid
);
1467 cifs_dbg(FYI
, "%s: total_read=%u data_offset=%u\n",
1468 __func__
, server
->total_read
, data_offset
);
1470 len
= data_offset
- server
->total_read
;
1472 /* read any junk before data into the rest of smallbuf */
1473 rdata
->iov
.iov_base
= buf
+ server
->total_read
;
1474 rdata
->iov
.iov_len
= len
;
1475 length
= cifs_readv_from_socket(server
, &rdata
->iov
, 1, len
);
1478 server
->total_read
+= length
;
1481 /* set up first iov for signature check */
1482 rdata
->iov
.iov_base
= buf
;
1483 rdata
->iov
.iov_len
= server
->total_read
;
1484 cifs_dbg(FYI
, "0: iov_base=%p iov_len=%zu\n",
1485 rdata
->iov
.iov_base
, rdata
->iov
.iov_len
);
1487 /* how much data is in the response? */
1488 data_len
= server
->ops
->read_data_length(buf
);
1489 if (data_offset
+ data_len
> buflen
) {
1490 /* data_len is corrupt -- discard frame */
1491 rdata
->result
= -EIO
;
1492 return cifs_readv_discard(server
, mid
);
1495 length
= rdata
->read_into_pages(server
, rdata
, data_len
);
1499 server
->total_read
+= length
;
1500 rdata
->bytes
= length
;
1502 cifs_dbg(FYI
, "total_read=%u buflen=%u remaining=%u\n",
1503 server
->total_read
, buflen
, data_len
);
1505 /* discard anything left over */
1506 if (server
->total_read
< buflen
)
1507 return cifs_readv_discard(server
, mid
);
1509 dequeue_mid(mid
, false);
1514 cifs_readv_callback(struct mid_q_entry
*mid
)
1516 struct cifs_readdata
*rdata
= mid
->callback_data
;
1517 struct cifs_tcon
*tcon
= tlink_tcon(rdata
->cfile
->tlink
);
1518 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1519 struct smb_rqst rqst
= { .rq_iov
= &rdata
->iov
,
1521 .rq_pages
= rdata
->pages
,
1522 .rq_npages
= rdata
->nr_pages
,
1523 .rq_pagesz
= rdata
->pagesz
,
1524 .rq_tailsz
= rdata
->tailsz
};
1526 cifs_dbg(FYI
, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1527 __func__
, mid
->mid
, mid
->mid_state
, rdata
->result
,
1530 switch (mid
->mid_state
) {
1531 case MID_RESPONSE_RECEIVED
:
1532 /* result already set, check signature */
1536 rc
= cifs_verify_signature(&rqst
, server
,
1537 mid
->sequence_number
);
1539 cifs_dbg(VFS
, "SMB signature verification returned error = %d\n",
1542 /* FIXME: should this be counted toward the initiating task? */
1543 task_io_account_read(rdata
->bytes
);
1544 cifs_stats_bytes_read(tcon
, rdata
->bytes
);
1546 case MID_REQUEST_SUBMITTED
:
1547 case MID_RETRY_NEEDED
:
1548 rdata
->result
= -EAGAIN
;
1551 rdata
->result
= -EIO
;
1554 queue_work(cifsiod_wq
, &rdata
->work
);
1555 DeleteMidQEntry(mid
);
1556 add_credits(server
, 1, 0);
1559 /* cifs_async_readv - send an async write, and set up mid to handle result */
1561 cifs_async_readv(struct cifs_readdata
*rdata
)
1564 READ_REQ
*smb
= NULL
;
1566 struct cifs_tcon
*tcon
= tlink_tcon(rdata
->cfile
->tlink
);
1567 struct smb_rqst rqst
= { .rq_iov
= &rdata
->iov
,
1570 cifs_dbg(FYI
, "%s: offset=%llu bytes=%u\n",
1571 __func__
, rdata
->offset
, rdata
->bytes
);
1573 if (tcon
->ses
->capabilities
& CAP_LARGE_FILES
)
1576 wct
= 10; /* old style read */
1577 if ((rdata
->offset
>> 32) > 0) {
1578 /* can not handle this big offset for old */
1583 rc
= small_smb_init(SMB_COM_READ_ANDX
, wct
, tcon
, (void **)&smb
);
1587 smb
->hdr
.Pid
= cpu_to_le16((__u16
)rdata
->pid
);
1588 smb
->hdr
.PidHigh
= cpu_to_le16((__u16
)(rdata
->pid
>> 16));
1590 smb
->AndXCommand
= 0xFF; /* none */
1591 smb
->Fid
= rdata
->cfile
->fid
.netfid
;
1592 smb
->OffsetLow
= cpu_to_le32(rdata
->offset
& 0xFFFFFFFF);
1594 smb
->OffsetHigh
= cpu_to_le32(rdata
->offset
>> 32);
1596 smb
->MaxCount
= cpu_to_le16(rdata
->bytes
& 0xFFFF);
1597 smb
->MaxCountHigh
= cpu_to_le32(rdata
->bytes
>> 16);
1601 /* old style read */
1602 struct smb_com_readx_req
*smbr
=
1603 (struct smb_com_readx_req
*)smb
;
1604 smbr
->ByteCount
= 0;
1607 /* 4 for RFC1001 length + 1 for BCC */
1608 rdata
->iov
.iov_base
= smb
;
1609 rdata
->iov
.iov_len
= be32_to_cpu(smb
->hdr
.smb_buf_length
) + 4;
1611 kref_get(&rdata
->refcount
);
1612 rc
= cifs_call_async(tcon
->ses
->server
, &rqst
, cifs_readv_receive
,
1613 cifs_readv_callback
, rdata
, 0);
1616 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_reads
);
1618 kref_put(&rdata
->refcount
, cifs_readdata_release
);
1620 cifs_small_buf_release(smb
);
1625 CIFSSMBRead(const unsigned int xid
, struct cifs_io_parms
*io_parms
,
1626 unsigned int *nbytes
, char **buf
, int *pbuf_type
)
1629 READ_REQ
*pSMB
= NULL
;
1630 READ_RSP
*pSMBr
= NULL
;
1631 char *pReadData
= NULL
;
1633 int resp_buf_type
= 0;
1635 __u32 pid
= io_parms
->pid
;
1636 __u16 netfid
= io_parms
->netfid
;
1637 __u64 offset
= io_parms
->offset
;
1638 struct cifs_tcon
*tcon
= io_parms
->tcon
;
1639 unsigned int count
= io_parms
->length
;
1641 cifs_dbg(FYI
, "Reading %d bytes on fid %d\n", count
, netfid
);
1642 if (tcon
->ses
->capabilities
& CAP_LARGE_FILES
)
1645 wct
= 10; /* old style read */
1646 if ((offset
>> 32) > 0) {
1647 /* can not handle this big offset for old */
1653 rc
= small_smb_init(SMB_COM_READ_ANDX
, wct
, tcon
, (void **) &pSMB
);
1657 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid
);
1658 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid
>> 16));
1660 /* tcon and ses pointer are checked in smb_init */
1661 if (tcon
->ses
->server
== NULL
)
1662 return -ECONNABORTED
;
1664 pSMB
->AndXCommand
= 0xFF; /* none */
1666 pSMB
->OffsetLow
= cpu_to_le32(offset
& 0xFFFFFFFF);
1668 pSMB
->OffsetHigh
= cpu_to_le32(offset
>> 32);
1670 pSMB
->Remaining
= 0;
1671 pSMB
->MaxCount
= cpu_to_le16(count
& 0xFFFF);
1672 pSMB
->MaxCountHigh
= cpu_to_le32(count
>> 16);
1674 pSMB
->ByteCount
= 0; /* no need to do le conversion since 0 */
1676 /* old style read */
1677 struct smb_com_readx_req
*pSMBW
=
1678 (struct smb_com_readx_req
*)pSMB
;
1679 pSMBW
->ByteCount
= 0;
1682 iov
[0].iov_base
= (char *)pSMB
;
1683 iov
[0].iov_len
= be32_to_cpu(pSMB
->hdr
.smb_buf_length
) + 4;
1684 rc
= SendReceive2(xid
, tcon
->ses
, iov
, 1 /* num iovecs */,
1685 &resp_buf_type
, CIFS_LOG_ERROR
);
1686 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_reads
);
1687 pSMBr
= (READ_RSP
*)iov
[0].iov_base
;
1689 cifs_dbg(VFS
, "Send error in read = %d\n", rc
);
1691 int data_length
= le16_to_cpu(pSMBr
->DataLengthHigh
);
1692 data_length
= data_length
<< 16;
1693 data_length
+= le16_to_cpu(pSMBr
->DataLength
);
1694 *nbytes
= data_length
;
1696 /*check that DataLength would not go beyond end of SMB */
1697 if ((data_length
> CIFSMaxBufSize
)
1698 || (data_length
> count
)) {
1699 cifs_dbg(FYI
, "bad length %d for count %d\n",
1700 data_length
, count
);
1704 pReadData
= (char *) (&pSMBr
->hdr
.Protocol
) +
1705 le16_to_cpu(pSMBr
->DataOffset
);
1706 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1707 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
1709 }*/ /* can not use copy_to_user when using page cache*/
1711 memcpy(*buf
, pReadData
, data_length
);
1715 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1717 if (resp_buf_type
== CIFS_SMALL_BUFFER
)
1718 cifs_small_buf_release(iov
[0].iov_base
);
1719 else if (resp_buf_type
== CIFS_LARGE_BUFFER
)
1720 cifs_buf_release(iov
[0].iov_base
);
1721 } else if (resp_buf_type
!= CIFS_NO_BUFFER
) {
1722 /* return buffer to caller to free */
1723 *buf
= iov
[0].iov_base
;
1724 if (resp_buf_type
== CIFS_SMALL_BUFFER
)
1725 *pbuf_type
= CIFS_SMALL_BUFFER
;
1726 else if (resp_buf_type
== CIFS_LARGE_BUFFER
)
1727 *pbuf_type
= CIFS_LARGE_BUFFER
;
1728 } /* else no valid buffer on return - leave as null */
1730 /* Note: On -EAGAIN error only caller can retry on handle based calls
1731 since file handle passed in no longer valid */
1737 CIFSSMBWrite(const unsigned int xid
, struct cifs_io_parms
*io_parms
,
1738 unsigned int *nbytes
, const char *buf
,
1739 const char __user
*ubuf
, const int long_op
)
1742 WRITE_REQ
*pSMB
= NULL
;
1743 WRITE_RSP
*pSMBr
= NULL
;
1744 int bytes_returned
, wct
;
1747 __u32 pid
= io_parms
->pid
;
1748 __u16 netfid
= io_parms
->netfid
;
1749 __u64 offset
= io_parms
->offset
;
1750 struct cifs_tcon
*tcon
= io_parms
->tcon
;
1751 unsigned int count
= io_parms
->length
;
1755 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
1756 if (tcon
->ses
== NULL
)
1757 return -ECONNABORTED
;
1759 if (tcon
->ses
->capabilities
& CAP_LARGE_FILES
)
1763 if ((offset
>> 32) > 0) {
1764 /* can not handle big offset for old srv */
1769 rc
= smb_init(SMB_COM_WRITE_ANDX
, wct
, tcon
, (void **) &pSMB
,
1774 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid
);
1775 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid
>> 16));
1777 /* tcon and ses pointer are checked in smb_init */
1778 if (tcon
->ses
->server
== NULL
)
1779 return -ECONNABORTED
;
1781 pSMB
->AndXCommand
= 0xFF; /* none */
1783 pSMB
->OffsetLow
= cpu_to_le32(offset
& 0xFFFFFFFF);
1785 pSMB
->OffsetHigh
= cpu_to_le32(offset
>> 32);
1787 pSMB
->Reserved
= 0xFFFFFFFF;
1788 pSMB
->WriteMode
= 0;
1789 pSMB
->Remaining
= 0;
1791 /* Can increase buffer size if buffer is big enough in some cases ie we
1792 can send more if LARGE_WRITE_X capability returned by the server and if
1793 our buffer is big enough or if we convert to iovecs on socket writes
1794 and eliminate the copy to the CIFS buffer */
1795 if (tcon
->ses
->capabilities
& CAP_LARGE_WRITE_X
) {
1796 bytes_sent
= min_t(const unsigned int, CIFSMaxBufSize
, count
);
1798 bytes_sent
= (tcon
->ses
->server
->maxBuf
- MAX_CIFS_HDR_SIZE
)
1802 if (bytes_sent
> count
)
1805 cpu_to_le16(offsetof(struct smb_com_write_req
, Data
) - 4);
1807 memcpy(pSMB
->Data
, buf
, bytes_sent
);
1809 if (copy_from_user(pSMB
->Data
, ubuf
, bytes_sent
)) {
1810 cifs_buf_release(pSMB
);
1813 } else if (count
!= 0) {
1815 cifs_buf_release(pSMB
);
1817 } /* else setting file size with write of zero bytes */
1819 byte_count
= bytes_sent
+ 1; /* pad */
1820 else /* wct == 12 */
1821 byte_count
= bytes_sent
+ 5; /* bigger pad, smaller smb hdr */
1823 pSMB
->DataLengthLow
= cpu_to_le16(bytes_sent
& 0xFFFF);
1824 pSMB
->DataLengthHigh
= cpu_to_le16(bytes_sent
>> 16);
1825 inc_rfc1001_len(pSMB
, byte_count
);
1828 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
1829 else { /* old style write has byte count 4 bytes earlier
1831 struct smb_com_writex_req
*pSMBW
=
1832 (struct smb_com_writex_req
*)pSMB
;
1833 pSMBW
->ByteCount
= cpu_to_le16(byte_count
);
1836 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
1837 (struct smb_hdr
*) pSMBr
, &bytes_returned
, long_op
);
1838 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_writes
);
1840 cifs_dbg(FYI
, "Send error in write = %d\n", rc
);
1842 *nbytes
= le16_to_cpu(pSMBr
->CountHigh
);
1843 *nbytes
= (*nbytes
) << 16;
1844 *nbytes
+= le16_to_cpu(pSMBr
->Count
);
1847 * Mask off high 16 bits when bytes written as returned by the
1848 * server is greater than bytes requested by the client. Some
1849 * OS/2 servers are known to set incorrect CountHigh values.
1851 if (*nbytes
> count
)
1855 cifs_buf_release(pSMB
);
1857 /* Note: On -EAGAIN error only caller can retry on handle based calls
1858 since file handle passed in no longer valid */
1864 cifs_writedata_release(struct kref
*refcount
)
1866 struct cifs_writedata
*wdata
= container_of(refcount
,
1867 struct cifs_writedata
, refcount
);
1870 cifsFileInfo_put(wdata
->cfile
);
1876 * Write failed with a retryable error. Resend the write request. It's also
1877 * possible that the page was redirtied so re-clean the page.
1880 cifs_writev_requeue(struct cifs_writedata
*wdata
)
1883 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
1884 struct TCP_Server_Info
*server
;
1886 for (i
= 0; i
< wdata
->nr_pages
; i
++) {
1887 lock_page(wdata
->pages
[i
]);
1888 clear_page_dirty_for_io(wdata
->pages
[i
]);
1892 server
= tlink_tcon(wdata
->cfile
->tlink
)->ses
->server
;
1893 rc
= server
->ops
->async_writev(wdata
);
1894 } while (rc
== -EAGAIN
);
1896 for (i
= 0; i
< wdata
->nr_pages
; i
++) {
1897 unlock_page(wdata
->pages
[i
]);
1899 SetPageError(wdata
->pages
[i
]);
1900 end_page_writeback(wdata
->pages
[i
]);
1901 page_cache_release(wdata
->pages
[i
]);
1905 mapping_set_error(inode
->i_mapping
, rc
);
1906 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1910 cifs_writev_complete(struct work_struct
*work
)
1912 struct cifs_writedata
*wdata
= container_of(work
,
1913 struct cifs_writedata
, work
);
1914 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
1917 if (wdata
->result
== 0) {
1918 spin_lock(&inode
->i_lock
);
1919 cifs_update_eof(CIFS_I(inode
), wdata
->offset
, wdata
->bytes
);
1920 spin_unlock(&inode
->i_lock
);
1921 cifs_stats_bytes_written(tlink_tcon(wdata
->cfile
->tlink
),
1923 } else if (wdata
->sync_mode
== WB_SYNC_ALL
&& wdata
->result
== -EAGAIN
)
1924 return cifs_writev_requeue(wdata
);
1926 for (i
= 0; i
< wdata
->nr_pages
; i
++) {
1927 struct page
*page
= wdata
->pages
[i
];
1928 if (wdata
->result
== -EAGAIN
)
1929 __set_page_dirty_nobuffers(page
);
1930 else if (wdata
->result
< 0)
1932 end_page_writeback(page
);
1933 page_cache_release(page
);
1935 if (wdata
->result
!= -EAGAIN
)
1936 mapping_set_error(inode
->i_mapping
, wdata
->result
);
1937 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1940 struct cifs_writedata
*
1941 cifs_writedata_alloc(unsigned int nr_pages
, work_func_t complete
)
1943 struct cifs_writedata
*wdata
;
1945 /* this would overflow */
1946 if (nr_pages
== 0) {
1947 cifs_dbg(VFS
, "%s: called with nr_pages == 0!\n", __func__
);
1951 /* writedata + number of page pointers */
1952 wdata
= kzalloc(sizeof(*wdata
) +
1953 sizeof(struct page
*) * (nr_pages
- 1), GFP_NOFS
);
1954 if (wdata
!= NULL
) {
1955 kref_init(&wdata
->refcount
);
1956 INIT_LIST_HEAD(&wdata
->list
);
1957 init_completion(&wdata
->done
);
1958 INIT_WORK(&wdata
->work
, complete
);
1964 * Check the mid_state and signature on received buffer (if any), and queue the
1965 * workqueue completion task.
1968 cifs_writev_callback(struct mid_q_entry
*mid
)
1970 struct cifs_writedata
*wdata
= mid
->callback_data
;
1971 struct cifs_tcon
*tcon
= tlink_tcon(wdata
->cfile
->tlink
);
1972 unsigned int written
;
1973 WRITE_RSP
*smb
= (WRITE_RSP
*)mid
->resp_buf
;
1975 switch (mid
->mid_state
) {
1976 case MID_RESPONSE_RECEIVED
:
1977 wdata
->result
= cifs_check_receive(mid
, tcon
->ses
->server
, 0);
1978 if (wdata
->result
!= 0)
1981 written
= le16_to_cpu(smb
->CountHigh
);
1983 written
+= le16_to_cpu(smb
->Count
);
1985 * Mask off high 16 bits when bytes written as returned
1986 * by the server is greater than bytes requested by the
1987 * client. OS/2 servers are known to set incorrect
1990 if (written
> wdata
->bytes
)
1993 if (written
< wdata
->bytes
)
1994 wdata
->result
= -ENOSPC
;
1996 wdata
->bytes
= written
;
1998 case MID_REQUEST_SUBMITTED
:
1999 case MID_RETRY_NEEDED
:
2000 wdata
->result
= -EAGAIN
;
2003 wdata
->result
= -EIO
;
2007 queue_work(cifsiod_wq
, &wdata
->work
);
2008 DeleteMidQEntry(mid
);
2009 add_credits(tcon
->ses
->server
, 1, 0);
2012 /* cifs_async_writev - send an async write, and set up mid to handle result */
2014 cifs_async_writev(struct cifs_writedata
*wdata
)
2017 WRITE_REQ
*smb
= NULL
;
2019 struct cifs_tcon
*tcon
= tlink_tcon(wdata
->cfile
->tlink
);
2021 struct smb_rqst rqst
= { };
2023 if (tcon
->ses
->capabilities
& CAP_LARGE_FILES
) {
2027 if (wdata
->offset
>> 32 > 0) {
2028 /* can not handle big offset for old srv */
2033 rc
= small_smb_init(SMB_COM_WRITE_ANDX
, wct
, tcon
, (void **)&smb
);
2035 goto async_writev_out
;
2037 smb
->hdr
.Pid
= cpu_to_le16((__u16
)wdata
->pid
);
2038 smb
->hdr
.PidHigh
= cpu_to_le16((__u16
)(wdata
->pid
>> 16));
2040 smb
->AndXCommand
= 0xFF; /* none */
2041 smb
->Fid
= wdata
->cfile
->fid
.netfid
;
2042 smb
->OffsetLow
= cpu_to_le32(wdata
->offset
& 0xFFFFFFFF);
2044 smb
->OffsetHigh
= cpu_to_le32(wdata
->offset
>> 32);
2045 smb
->Reserved
= 0xFFFFFFFF;
2050 cpu_to_le16(offsetof(struct smb_com_write_req
, Data
) - 4);
2052 /* 4 for RFC1001 length + 1 for BCC */
2053 iov
.iov_len
= be32_to_cpu(smb
->hdr
.smb_buf_length
) + 4 + 1;
2058 rqst
.rq_pages
= wdata
->pages
;
2059 rqst
.rq_npages
= wdata
->nr_pages
;
2060 rqst
.rq_pagesz
= wdata
->pagesz
;
2061 rqst
.rq_tailsz
= wdata
->tailsz
;
2063 cifs_dbg(FYI
, "async write at %llu %u bytes\n",
2064 wdata
->offset
, wdata
->bytes
);
2066 smb
->DataLengthLow
= cpu_to_le16(wdata
->bytes
& 0xFFFF);
2067 smb
->DataLengthHigh
= cpu_to_le16(wdata
->bytes
>> 16);
2070 inc_rfc1001_len(&smb
->hdr
, wdata
->bytes
+ 1);
2071 put_bcc(wdata
->bytes
+ 1, &smb
->hdr
);
2074 struct smb_com_writex_req
*smbw
=
2075 (struct smb_com_writex_req
*)smb
;
2076 inc_rfc1001_len(&smbw
->hdr
, wdata
->bytes
+ 5);
2077 put_bcc(wdata
->bytes
+ 5, &smbw
->hdr
);
2078 iov
.iov_len
+= 4; /* pad bigger by four bytes */
2081 kref_get(&wdata
->refcount
);
2082 rc
= cifs_call_async(tcon
->ses
->server
, &rqst
, NULL
,
2083 cifs_writev_callback
, wdata
, 0);
2086 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_writes
);
2088 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2091 cifs_small_buf_release(smb
);
2096 CIFSSMBWrite2(const unsigned int xid
, struct cifs_io_parms
*io_parms
,
2097 unsigned int *nbytes
, struct kvec
*iov
, int n_vec
)
2100 WRITE_REQ
*pSMB
= NULL
;
2103 int resp_buf_type
= 0;
2104 __u32 pid
= io_parms
->pid
;
2105 __u16 netfid
= io_parms
->netfid
;
2106 __u64 offset
= io_parms
->offset
;
2107 struct cifs_tcon
*tcon
= io_parms
->tcon
;
2108 unsigned int count
= io_parms
->length
;
2112 cifs_dbg(FYI
, "write2 at %lld %d bytes\n", (long long)offset
, count
);
2114 if (tcon
->ses
->capabilities
& CAP_LARGE_FILES
) {
2118 if ((offset
>> 32) > 0) {
2119 /* can not handle big offset for old srv */
2123 rc
= small_smb_init(SMB_COM_WRITE_ANDX
, wct
, tcon
, (void **) &pSMB
);
2127 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid
);
2128 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid
>> 16));
2130 /* tcon and ses pointer are checked in smb_init */
2131 if (tcon
->ses
->server
== NULL
)
2132 return -ECONNABORTED
;
2134 pSMB
->AndXCommand
= 0xFF; /* none */
2136 pSMB
->OffsetLow
= cpu_to_le32(offset
& 0xFFFFFFFF);
2138 pSMB
->OffsetHigh
= cpu_to_le32(offset
>> 32);
2139 pSMB
->Reserved
= 0xFFFFFFFF;
2140 pSMB
->WriteMode
= 0;
2141 pSMB
->Remaining
= 0;
2144 cpu_to_le16(offsetof(struct smb_com_write_req
, Data
) - 4);
2146 pSMB
->DataLengthLow
= cpu_to_le16(count
& 0xFFFF);
2147 pSMB
->DataLengthHigh
= cpu_to_le16(count
>> 16);
2148 /* header + 1 byte pad */
2149 smb_hdr_len
= be32_to_cpu(pSMB
->hdr
.smb_buf_length
) + 1;
2151 inc_rfc1001_len(pSMB
, count
+ 1);
2152 else /* wct == 12 */
2153 inc_rfc1001_len(pSMB
, count
+ 5); /* smb data starts later */
2155 pSMB
->ByteCount
= cpu_to_le16(count
+ 1);
2156 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2157 struct smb_com_writex_req
*pSMBW
=
2158 (struct smb_com_writex_req
*)pSMB
;
2159 pSMBW
->ByteCount
= cpu_to_le16(count
+ 5);
2161 iov
[0].iov_base
= pSMB
;
2163 iov
[0].iov_len
= smb_hdr_len
+ 4;
2164 else /* wct == 12 pad bigger by four bytes */
2165 iov
[0].iov_len
= smb_hdr_len
+ 8;
2168 rc
= SendReceive2(xid
, tcon
->ses
, iov
, n_vec
+ 1, &resp_buf_type
, 0);
2169 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_writes
);
2171 cifs_dbg(FYI
, "Send error Write2 = %d\n", rc
);
2172 } else if (resp_buf_type
== 0) {
2173 /* presumably this can not happen, but best to be safe */
2176 WRITE_RSP
*pSMBr
= (WRITE_RSP
*)iov
[0].iov_base
;
2177 *nbytes
= le16_to_cpu(pSMBr
->CountHigh
);
2178 *nbytes
= (*nbytes
) << 16;
2179 *nbytes
+= le16_to_cpu(pSMBr
->Count
);
2182 * Mask off high 16 bits when bytes written as returned by the
2183 * server is greater than bytes requested by the client. OS/2
2184 * servers are known to set incorrect CountHigh values.
2186 if (*nbytes
> count
)
2190 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2191 if (resp_buf_type
== CIFS_SMALL_BUFFER
)
2192 cifs_small_buf_release(iov
[0].iov_base
);
2193 else if (resp_buf_type
== CIFS_LARGE_BUFFER
)
2194 cifs_buf_release(iov
[0].iov_base
);
2196 /* Note: On -EAGAIN error only caller can retry on handle based calls
2197 since file handle passed in no longer valid */
2202 int cifs_lockv(const unsigned int xid
, struct cifs_tcon
*tcon
,
2203 const __u16 netfid
, const __u8 lock_type
, const __u32 num_unlock
,
2204 const __u32 num_lock
, LOCKING_ANDX_RANGE
*buf
)
2207 LOCK_REQ
*pSMB
= NULL
;
2212 cifs_dbg(FYI
, "cifs_lockv num lock %d num unlock %d\n",
2213 num_lock
, num_unlock
);
2215 rc
= small_smb_init(SMB_COM_LOCKING_ANDX
, 8, tcon
, (void **) &pSMB
);
2220 pSMB
->NumberOfLocks
= cpu_to_le16(num_lock
);
2221 pSMB
->NumberOfUnlocks
= cpu_to_le16(num_unlock
);
2222 pSMB
->LockType
= lock_type
;
2223 pSMB
->AndXCommand
= 0xFF; /* none */
2224 pSMB
->Fid
= netfid
; /* netfid stays le */
2226 count
= (num_unlock
+ num_lock
) * sizeof(LOCKING_ANDX_RANGE
);
2227 inc_rfc1001_len(pSMB
, count
);
2228 pSMB
->ByteCount
= cpu_to_le16(count
);
2230 iov
[0].iov_base
= (char *)pSMB
;
2231 iov
[0].iov_len
= be32_to_cpu(pSMB
->hdr
.smb_buf_length
) + 4 -
2232 (num_unlock
+ num_lock
) * sizeof(LOCKING_ANDX_RANGE
);
2233 iov
[1].iov_base
= (char *)buf
;
2234 iov
[1].iov_len
= (num_unlock
+ num_lock
) * sizeof(LOCKING_ANDX_RANGE
);
2236 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_locks
);
2237 rc
= SendReceive2(xid
, tcon
->ses
, iov
, 2, &resp_buf_type
, CIFS_NO_RESP
);
2239 cifs_dbg(FYI
, "Send error in cifs_lockv = %d\n", rc
);
2245 CIFSSMBLock(const unsigned int xid
, struct cifs_tcon
*tcon
,
2246 const __u16 smb_file_id
, const __u32 netpid
, const __u64 len
,
2247 const __u64 offset
, const __u32 numUnlock
,
2248 const __u32 numLock
, const __u8 lockType
,
2249 const bool waitFlag
, const __u8 oplock_level
)
2252 LOCK_REQ
*pSMB
= NULL
;
2253 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2258 cifs_dbg(FYI
, "CIFSSMBLock timeout %d numLock %d\n",
2259 (int)waitFlag
, numLock
);
2260 rc
= small_smb_init(SMB_COM_LOCKING_ANDX
, 8, tcon
, (void **) &pSMB
);
2265 if (lockType
== LOCKING_ANDX_OPLOCK_RELEASE
) {
2266 /* no response expected */
2267 flags
= CIFS_ASYNC_OP
| CIFS_OBREAK_OP
;
2269 } else if (waitFlag
) {
2270 flags
= CIFS_BLOCKING_OP
; /* blocking operation, no timeout */
2271 pSMB
->Timeout
= cpu_to_le32(-1);/* blocking - do not time out */
2276 pSMB
->NumberOfLocks
= cpu_to_le16(numLock
);
2277 pSMB
->NumberOfUnlocks
= cpu_to_le16(numUnlock
);
2278 pSMB
->LockType
= lockType
;
2279 pSMB
->OplockLevel
= oplock_level
;
2280 pSMB
->AndXCommand
= 0xFF; /* none */
2281 pSMB
->Fid
= smb_file_id
; /* netfid stays le */
2283 if ((numLock
!= 0) || (numUnlock
!= 0)) {
2284 pSMB
->Locks
[0].Pid
= cpu_to_le16(netpid
);
2285 /* BB where to store pid high? */
2286 pSMB
->Locks
[0].LengthLow
= cpu_to_le32((u32
)len
);
2287 pSMB
->Locks
[0].LengthHigh
= cpu_to_le32((u32
)(len
>>32));
2288 pSMB
->Locks
[0].OffsetLow
= cpu_to_le32((u32
)offset
);
2289 pSMB
->Locks
[0].OffsetHigh
= cpu_to_le32((u32
)(offset
>>32));
2290 count
= sizeof(LOCKING_ANDX_RANGE
);
2295 inc_rfc1001_len(pSMB
, count
);
2296 pSMB
->ByteCount
= cpu_to_le16(count
);
2299 rc
= SendReceiveBlockingLock(xid
, tcon
, (struct smb_hdr
*) pSMB
,
2300 (struct smb_hdr
*) pSMB
, &bytes_returned
);
2301 cifs_small_buf_release(pSMB
);
2303 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *)pSMB
, flags
);
2304 /* SMB buffer freed by function above */
2306 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_locks
);
2308 cifs_dbg(FYI
, "Send error in Lock = %d\n", rc
);
2310 /* Note: On -EAGAIN error only caller can retry on handle based calls
2311 since file handle passed in no longer valid */
2316 CIFSSMBPosixLock(const unsigned int xid
, struct cifs_tcon
*tcon
,
2317 const __u16 smb_file_id
, const __u32 netpid
,
2318 const loff_t start_offset
, const __u64 len
,
2319 struct file_lock
*pLockData
, const __u16 lock_type
,
2320 const bool waitFlag
)
2322 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
2323 struct smb_com_transaction2_sfi_rsp
*pSMBr
= NULL
;
2324 struct cifs_posix_lock
*parm_data
;
2327 int bytes_returned
= 0;
2328 int resp_buf_type
= 0;
2329 __u16 params
, param_offset
, offset
, byte_count
, count
;
2332 cifs_dbg(FYI
, "Posix Lock\n");
2334 rc
= small_smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
);
2339 pSMBr
= (struct smb_com_transaction2_sfi_rsp
*)pSMB
;
2342 pSMB
->MaxSetupCount
= 0;
2345 pSMB
->Reserved2
= 0;
2346 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
2347 offset
= param_offset
+ params
;
2349 count
= sizeof(struct cifs_posix_lock
);
2350 pSMB
->MaxParameterCount
= cpu_to_le16(2);
2351 pSMB
->MaxDataCount
= cpu_to_le16(1000); /* BB find max SMB from sess */
2352 pSMB
->SetupCount
= 1;
2353 pSMB
->Reserved3
= 0;
2355 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION
);
2357 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
2358 byte_count
= 3 /* pad */ + params
+ count
;
2359 pSMB
->DataCount
= cpu_to_le16(count
);
2360 pSMB
->ParameterCount
= cpu_to_le16(params
);
2361 pSMB
->TotalDataCount
= pSMB
->DataCount
;
2362 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
2363 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
2364 parm_data
= (struct cifs_posix_lock
*)
2365 (((char *) &pSMB
->hdr
.Protocol
) + offset
);
2367 parm_data
->lock_type
= cpu_to_le16(lock_type
);
2369 timeout
= CIFS_BLOCKING_OP
; /* blocking operation, no timeout */
2370 parm_data
->lock_flags
= cpu_to_le16(1);
2371 pSMB
->Timeout
= cpu_to_le32(-1);
2375 parm_data
->pid
= cpu_to_le32(netpid
);
2376 parm_data
->start
= cpu_to_le64(start_offset
);
2377 parm_data
->length
= cpu_to_le64(len
); /* normalize negative numbers */
2379 pSMB
->DataOffset
= cpu_to_le16(offset
);
2380 pSMB
->Fid
= smb_file_id
;
2381 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_POSIX_LOCK
);
2382 pSMB
->Reserved4
= 0;
2383 inc_rfc1001_len(pSMB
, byte_count
);
2384 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
2386 rc
= SendReceiveBlockingLock(xid
, tcon
, (struct smb_hdr
*) pSMB
,
2387 (struct smb_hdr
*) pSMBr
, &bytes_returned
);
2389 iov
[0].iov_base
= (char *)pSMB
;
2390 iov
[0].iov_len
= be32_to_cpu(pSMB
->hdr
.smb_buf_length
) + 4;
2391 rc
= SendReceive2(xid
, tcon
->ses
, iov
, 1 /* num iovecs */,
2392 &resp_buf_type
, timeout
);
2393 pSMB
= NULL
; /* request buf already freed by SendReceive2. Do
2394 not try to free it twice below on exit */
2395 pSMBr
= (struct smb_com_transaction2_sfi_rsp
*)iov
[0].iov_base
;
2399 cifs_dbg(FYI
, "Send error in Posix Lock = %d\n", rc
);
2400 } else if (pLockData
) {
2401 /* lock structure can be returned on get */
2404 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
2406 if (rc
|| get_bcc(&pSMBr
->hdr
) < sizeof(*parm_data
)) {
2407 rc
= -EIO
; /* bad smb */
2410 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
2411 data_count
= le16_to_cpu(pSMBr
->t2
.DataCount
);
2412 if (data_count
< sizeof(struct cifs_posix_lock
)) {
2416 parm_data
= (struct cifs_posix_lock
*)
2417 ((char *)&pSMBr
->hdr
.Protocol
+ data_offset
);
2418 if (parm_data
->lock_type
== __constant_cpu_to_le16(CIFS_UNLCK
))
2419 pLockData
->fl_type
= F_UNLCK
;
2421 if (parm_data
->lock_type
==
2422 __constant_cpu_to_le16(CIFS_RDLCK
))
2423 pLockData
->fl_type
= F_RDLCK
;
2424 else if (parm_data
->lock_type
==
2425 __constant_cpu_to_le16(CIFS_WRLCK
))
2426 pLockData
->fl_type
= F_WRLCK
;
2428 pLockData
->fl_start
= le64_to_cpu(parm_data
->start
);
2429 pLockData
->fl_end
= pLockData
->fl_start
+
2430 le64_to_cpu(parm_data
->length
) - 1;
2431 pLockData
->fl_pid
= le32_to_cpu(parm_data
->pid
);
2437 cifs_small_buf_release(pSMB
);
2439 if (resp_buf_type
== CIFS_SMALL_BUFFER
)
2440 cifs_small_buf_release(iov
[0].iov_base
);
2441 else if (resp_buf_type
== CIFS_LARGE_BUFFER
)
2442 cifs_buf_release(iov
[0].iov_base
);
2444 /* Note: On -EAGAIN error only caller can retry on handle based calls
2445 since file handle passed in no longer valid */
2452 CIFSSMBClose(const unsigned int xid
, struct cifs_tcon
*tcon
, int smb_file_id
)
2455 CLOSE_REQ
*pSMB
= NULL
;
2456 cifs_dbg(FYI
, "In CIFSSMBClose\n");
2458 /* do not retry on dead session on close */
2459 rc
= small_smb_init(SMB_COM_CLOSE
, 3, tcon
, (void **) &pSMB
);
2465 pSMB
->FileID
= (__u16
) smb_file_id
;
2466 pSMB
->LastWriteTime
= 0xFFFFFFFF;
2467 pSMB
->ByteCount
= 0;
2468 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
2469 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_closes
);
2472 /* EINTR is expected when user ctl-c to kill app */
2473 cifs_dbg(VFS
, "Send error in Close = %d\n", rc
);
2477 /* Since session is dead, file will be closed on server already */
2485 CIFSSMBFlush(const unsigned int xid
, struct cifs_tcon
*tcon
, int smb_file_id
)
2488 FLUSH_REQ
*pSMB
= NULL
;
2489 cifs_dbg(FYI
, "In CIFSSMBFlush\n");
2491 rc
= small_smb_init(SMB_COM_FLUSH
, 1, tcon
, (void **) &pSMB
);
2495 pSMB
->FileID
= (__u16
) smb_file_id
;
2496 pSMB
->ByteCount
= 0;
2497 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
2498 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_flushes
);
2500 cifs_dbg(VFS
, "Send error in Flush = %d\n", rc
);
2506 CIFSSMBRename(const unsigned int xid
, struct cifs_tcon
*tcon
,
2507 const char *from_name
, const char *to_name
,
2508 struct cifs_sb_info
*cifs_sb
)
2511 RENAME_REQ
*pSMB
= NULL
;
2512 RENAME_RSP
*pSMBr
= NULL
;
2514 int name_len
, name_len2
;
2516 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
2518 cifs_dbg(FYI
, "In CIFSSMBRename\n");
2520 rc
= smb_init(SMB_COM_RENAME
, 1, tcon
, (void **) &pSMB
,
2525 pSMB
->BufferFormat
= 0x04;
2526 pSMB
->SearchAttributes
=
2527 cpu_to_le16(ATTR_READONLY
| ATTR_HIDDEN
| ATTR_SYSTEM
|
2530 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2531 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->OldFileName
,
2532 from_name
, PATH_MAX
,
2533 cifs_sb
->local_nls
, remap
);
2534 name_len
++; /* trailing null */
2536 pSMB
->OldFileName
[name_len
] = 0x04; /* pad */
2537 /* protocol requires ASCII signature byte on Unicode string */
2538 pSMB
->OldFileName
[name_len
+ 1] = 0x00;
2540 cifsConvertToUTF16((__le16
*)&pSMB
->OldFileName
[name_len
+2],
2541 to_name
, PATH_MAX
, cifs_sb
->local_nls
,
2543 name_len2
+= 1 /* trailing null */ + 1 /* Signature word */ ;
2544 name_len2
*= 2; /* convert to bytes */
2545 } else { /* BB improve the check for buffer overruns BB */
2546 name_len
= strnlen(from_name
, PATH_MAX
);
2547 name_len
++; /* trailing null */
2548 strncpy(pSMB
->OldFileName
, from_name
, name_len
);
2549 name_len2
= strnlen(to_name
, PATH_MAX
);
2550 name_len2
++; /* trailing null */
2551 pSMB
->OldFileName
[name_len
] = 0x04; /* 2nd buffer format */
2552 strncpy(&pSMB
->OldFileName
[name_len
+ 1], to_name
, name_len2
);
2553 name_len2
++; /* trailing null */
2554 name_len2
++; /* signature byte */
2557 count
= 1 /* 1st signature byte */ + name_len
+ name_len2
;
2558 inc_rfc1001_len(pSMB
, count
);
2559 pSMB
->ByteCount
= cpu_to_le16(count
);
2561 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
2562 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2563 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_renames
);
2565 cifs_dbg(FYI
, "Send error in rename = %d\n", rc
);
2567 cifs_buf_release(pSMB
);
2575 int CIFSSMBRenameOpenFile(const unsigned int xid
, struct cifs_tcon
*pTcon
,
2576 int netfid
, const char *target_name
,
2577 const struct nls_table
*nls_codepage
, int remap
)
2579 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
2580 struct smb_com_transaction2_sfi_rsp
*pSMBr
= NULL
;
2581 struct set_file_rename
*rename_info
;
2583 char dummy_string
[30];
2585 int bytes_returned
= 0;
2587 __u16 params
, param_offset
, offset
, count
, byte_count
;
2589 cifs_dbg(FYI
, "Rename to File by handle\n");
2590 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, pTcon
, (void **) &pSMB
,
2596 pSMB
->MaxSetupCount
= 0;
2600 pSMB
->Reserved2
= 0;
2601 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
2602 offset
= param_offset
+ params
;
2604 data_offset
= (char *) (&pSMB
->hdr
.Protocol
) + offset
;
2605 rename_info
= (struct set_file_rename
*) data_offset
;
2606 pSMB
->MaxParameterCount
= cpu_to_le16(2);
2607 pSMB
->MaxDataCount
= cpu_to_le16(1000); /* BB find max SMB from sess */
2608 pSMB
->SetupCount
= 1;
2609 pSMB
->Reserved3
= 0;
2610 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
2611 byte_count
= 3 /* pad */ + params
;
2612 pSMB
->ParameterCount
= cpu_to_le16(params
);
2613 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
2614 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
2615 pSMB
->DataOffset
= cpu_to_le16(offset
);
2616 /* construct random name ".cifs_tmp<inodenum><mid>" */
2617 rename_info
->overwrite
= cpu_to_le32(1);
2618 rename_info
->root_fid
= 0;
2619 /* unicode only call */
2620 if (target_name
== NULL
) {
2621 sprintf(dummy_string
, "cifs%x", pSMB
->hdr
.Mid
);
2623 cifsConvertToUTF16((__le16
*)rename_info
->target_name
,
2624 dummy_string
, 24, nls_codepage
, remap
);
2627 cifsConvertToUTF16((__le16
*)rename_info
->target_name
,
2628 target_name
, PATH_MAX
, nls_codepage
,
2631 rename_info
->target_name_len
= cpu_to_le32(2 * len_of_str
);
2632 count
= 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str
);
2633 byte_count
+= count
;
2634 pSMB
->DataCount
= cpu_to_le16(count
);
2635 pSMB
->TotalDataCount
= pSMB
->DataCount
;
2637 pSMB
->InformationLevel
=
2638 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION
);
2639 pSMB
->Reserved4
= 0;
2640 inc_rfc1001_len(pSMB
, byte_count
);
2641 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
2642 rc
= SendReceive(xid
, pTcon
->ses
, (struct smb_hdr
*) pSMB
,
2643 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2644 cifs_stats_inc(&pTcon
->stats
.cifs_stats
.num_t2renames
);
2646 cifs_dbg(FYI
, "Send error in Rename (by file handle) = %d\n",
2649 cifs_buf_release(pSMB
);
2651 /* Note: On -EAGAIN error only caller can retry on handle based calls
2652 since file handle passed in no longer valid */
2658 CIFSSMBCopy(const unsigned int xid
, struct cifs_tcon
*tcon
,
2659 const char *fromName
, const __u16 target_tid
, const char *toName
,
2660 const int flags
, const struct nls_table
*nls_codepage
, int remap
)
2663 COPY_REQ
*pSMB
= NULL
;
2664 COPY_RSP
*pSMBr
= NULL
;
2666 int name_len
, name_len2
;
2669 cifs_dbg(FYI
, "In CIFSSMBCopy\n");
2671 rc
= smb_init(SMB_COM_COPY
, 1, tcon
, (void **) &pSMB
,
2676 pSMB
->BufferFormat
= 0x04;
2677 pSMB
->Tid2
= target_tid
;
2679 pSMB
->Flags
= cpu_to_le16(flags
& COPY_TREE
);
2681 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2682 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->OldFileName
,
2683 fromName
, PATH_MAX
, nls_codepage
,
2685 name_len
++; /* trailing null */
2687 pSMB
->OldFileName
[name_len
] = 0x04; /* pad */
2688 /* protocol requires ASCII signature byte on Unicode string */
2689 pSMB
->OldFileName
[name_len
+ 1] = 0x00;
2691 cifsConvertToUTF16((__le16
*)&pSMB
->OldFileName
[name_len
+2],
2692 toName
, PATH_MAX
, nls_codepage
, remap
);
2693 name_len2
+= 1 /* trailing null */ + 1 /* Signature word */ ;
2694 name_len2
*= 2; /* convert to bytes */
2695 } else { /* BB improve the check for buffer overruns BB */
2696 name_len
= strnlen(fromName
, PATH_MAX
);
2697 name_len
++; /* trailing null */
2698 strncpy(pSMB
->OldFileName
, fromName
, name_len
);
2699 name_len2
= strnlen(toName
, PATH_MAX
);
2700 name_len2
++; /* trailing null */
2701 pSMB
->OldFileName
[name_len
] = 0x04; /* 2nd buffer format */
2702 strncpy(&pSMB
->OldFileName
[name_len
+ 1], toName
, name_len2
);
2703 name_len2
++; /* trailing null */
2704 name_len2
++; /* signature byte */
2707 count
= 1 /* 1st signature byte */ + name_len
+ name_len2
;
2708 inc_rfc1001_len(pSMB
, count
);
2709 pSMB
->ByteCount
= cpu_to_le16(count
);
2711 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
2712 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2714 cifs_dbg(FYI
, "Send error in copy = %d with %d files copied\n",
2715 rc
, le16_to_cpu(pSMBr
->CopyCount
));
2717 cifs_buf_release(pSMB
);
2726 CIFSUnixCreateSymLink(const unsigned int xid
, struct cifs_tcon
*tcon
,
2727 const char *fromName
, const char *toName
,
2728 const struct nls_table
*nls_codepage
)
2730 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
2731 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
2734 int name_len_target
;
2736 int bytes_returned
= 0;
2737 __u16 params
, param_offset
, offset
, byte_count
;
2739 cifs_dbg(FYI
, "In Symlink Unix style\n");
2741 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
2746 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2748 cifs_strtoUTF16((__le16
*) pSMB
->FileName
, fromName
,
2749 /* find define for this maxpathcomponent */
2750 PATH_MAX
, nls_codepage
);
2751 name_len
++; /* trailing null */
2754 } else { /* BB improve the check for buffer overruns BB */
2755 name_len
= strnlen(fromName
, PATH_MAX
);
2756 name_len
++; /* trailing null */
2757 strncpy(pSMB
->FileName
, fromName
, name_len
);
2759 params
= 6 + name_len
;
2760 pSMB
->MaxSetupCount
= 0;
2764 pSMB
->Reserved2
= 0;
2765 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
2766 InformationLevel
) - 4;
2767 offset
= param_offset
+ params
;
2769 data_offset
= (char *) (&pSMB
->hdr
.Protocol
) + offset
;
2770 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2772 cifs_strtoUTF16((__le16
*) data_offset
, toName
, PATH_MAX
2773 /* find define for this maxpathcomponent */
2775 name_len_target
++; /* trailing null */
2776 name_len_target
*= 2;
2777 } else { /* BB improve the check for buffer overruns BB */
2778 name_len_target
= strnlen(toName
, PATH_MAX
);
2779 name_len_target
++; /* trailing null */
2780 strncpy(data_offset
, toName
, name_len_target
);
2783 pSMB
->MaxParameterCount
= cpu_to_le16(2);
2784 /* BB find exact max on data count below from sess */
2785 pSMB
->MaxDataCount
= cpu_to_le16(1000);
2786 pSMB
->SetupCount
= 1;
2787 pSMB
->Reserved3
= 0;
2788 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
2789 byte_count
= 3 /* pad */ + params
+ name_len_target
;
2790 pSMB
->DataCount
= cpu_to_le16(name_len_target
);
2791 pSMB
->ParameterCount
= cpu_to_le16(params
);
2792 pSMB
->TotalDataCount
= pSMB
->DataCount
;
2793 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
2794 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
2795 pSMB
->DataOffset
= cpu_to_le16(offset
);
2796 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_UNIX_LINK
);
2797 pSMB
->Reserved4
= 0;
2798 inc_rfc1001_len(pSMB
, byte_count
);
2799 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
2800 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
2801 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2802 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_symlinks
);
2804 cifs_dbg(FYI
, "Send error in SetPathInfo create symlink = %d\n",
2807 cifs_buf_release(pSMB
);
2810 goto createSymLinkRetry
;
2816 CIFSUnixCreateHardLink(const unsigned int xid
, struct cifs_tcon
*tcon
,
2817 const char *fromName
, const char *toName
,
2818 const struct nls_table
*nls_codepage
, int remap
)
2820 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
2821 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
2824 int name_len_target
;
2826 int bytes_returned
= 0;
2827 __u16 params
, param_offset
, offset
, byte_count
;
2829 cifs_dbg(FYI
, "In Create Hard link Unix style\n");
2830 createHardLinkRetry
:
2831 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
2836 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2837 name_len
= cifsConvertToUTF16((__le16
*) pSMB
->FileName
, toName
,
2838 PATH_MAX
, nls_codepage
, remap
);
2839 name_len
++; /* trailing null */
2842 } else { /* BB improve the check for buffer overruns BB */
2843 name_len
= strnlen(toName
, PATH_MAX
);
2844 name_len
++; /* trailing null */
2845 strncpy(pSMB
->FileName
, toName
, name_len
);
2847 params
= 6 + name_len
;
2848 pSMB
->MaxSetupCount
= 0;
2852 pSMB
->Reserved2
= 0;
2853 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
2854 InformationLevel
) - 4;
2855 offset
= param_offset
+ params
;
2857 data_offset
= (char *) (&pSMB
->hdr
.Protocol
) + offset
;
2858 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2860 cifsConvertToUTF16((__le16
*) data_offset
, fromName
,
2861 PATH_MAX
, nls_codepage
, remap
);
2862 name_len_target
++; /* trailing null */
2863 name_len_target
*= 2;
2864 } else { /* BB improve the check for buffer overruns BB */
2865 name_len_target
= strnlen(fromName
, PATH_MAX
);
2866 name_len_target
++; /* trailing null */
2867 strncpy(data_offset
, fromName
, name_len_target
);
2870 pSMB
->MaxParameterCount
= cpu_to_le16(2);
2871 /* BB find exact max on data count below from sess*/
2872 pSMB
->MaxDataCount
= cpu_to_le16(1000);
2873 pSMB
->SetupCount
= 1;
2874 pSMB
->Reserved3
= 0;
2875 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
2876 byte_count
= 3 /* pad */ + params
+ name_len_target
;
2877 pSMB
->ParameterCount
= cpu_to_le16(params
);
2878 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
2879 pSMB
->DataCount
= cpu_to_le16(name_len_target
);
2880 pSMB
->TotalDataCount
= pSMB
->DataCount
;
2881 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
2882 pSMB
->DataOffset
= cpu_to_le16(offset
);
2883 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_UNIX_HLINK
);
2884 pSMB
->Reserved4
= 0;
2885 inc_rfc1001_len(pSMB
, byte_count
);
2886 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
2887 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
2888 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2889 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_hardlinks
);
2891 cifs_dbg(FYI
, "Send error in SetPathInfo (hard link) = %d\n",
2894 cifs_buf_release(pSMB
);
2896 goto createHardLinkRetry
;
2902 CIFSCreateHardLink(const unsigned int xid
, struct cifs_tcon
*tcon
,
2903 const char *from_name
, const char *to_name
,
2904 struct cifs_sb_info
*cifs_sb
)
2907 NT_RENAME_REQ
*pSMB
= NULL
;
2908 RENAME_RSP
*pSMBr
= NULL
;
2910 int name_len
, name_len2
;
2912 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
2914 cifs_dbg(FYI
, "In CIFSCreateHardLink\n");
2915 winCreateHardLinkRetry
:
2917 rc
= smb_init(SMB_COM_NT_RENAME
, 4, tcon
, (void **) &pSMB
,
2922 pSMB
->SearchAttributes
=
2923 cpu_to_le16(ATTR_READONLY
| ATTR_HIDDEN
| ATTR_SYSTEM
|
2925 pSMB
->Flags
= cpu_to_le16(CREATE_HARD_LINK
);
2926 pSMB
->ClusterCount
= 0;
2928 pSMB
->BufferFormat
= 0x04;
2930 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2932 cifsConvertToUTF16((__le16
*) pSMB
->OldFileName
, from_name
,
2933 PATH_MAX
, cifs_sb
->local_nls
, remap
);
2934 name_len
++; /* trailing null */
2937 /* protocol specifies ASCII buffer format (0x04) for unicode */
2938 pSMB
->OldFileName
[name_len
] = 0x04;
2939 pSMB
->OldFileName
[name_len
+ 1] = 0x00; /* pad */
2941 cifsConvertToUTF16((__le16
*)&pSMB
->OldFileName
[name_len
+2],
2942 to_name
, PATH_MAX
, cifs_sb
->local_nls
,
2944 name_len2
+= 1 /* trailing null */ + 1 /* Signature word */ ;
2945 name_len2
*= 2; /* convert to bytes */
2946 } else { /* BB improve the check for buffer overruns BB */
2947 name_len
= strnlen(from_name
, PATH_MAX
);
2948 name_len
++; /* trailing null */
2949 strncpy(pSMB
->OldFileName
, from_name
, name_len
);
2950 name_len2
= strnlen(to_name
, PATH_MAX
);
2951 name_len2
++; /* trailing null */
2952 pSMB
->OldFileName
[name_len
] = 0x04; /* 2nd buffer format */
2953 strncpy(&pSMB
->OldFileName
[name_len
+ 1], to_name
, name_len2
);
2954 name_len2
++; /* trailing null */
2955 name_len2
++; /* signature byte */
2958 count
= 1 /* string type byte */ + name_len
+ name_len2
;
2959 inc_rfc1001_len(pSMB
, count
);
2960 pSMB
->ByteCount
= cpu_to_le16(count
);
2962 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
2963 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
2964 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_hardlinks
);
2966 cifs_dbg(FYI
, "Send error in hard link (NT rename) = %d\n", rc
);
2968 cifs_buf_release(pSMB
);
2970 goto winCreateHardLinkRetry
;
2976 CIFSSMBUnixQuerySymLink(const unsigned int xid
, struct cifs_tcon
*tcon
,
2977 const unsigned char *searchName
, char **symlinkinfo
,
2978 const struct nls_table
*nls_codepage
)
2980 /* SMB_QUERY_FILE_UNIX_LINK */
2981 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
2982 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
2986 __u16 params
, byte_count
;
2989 cifs_dbg(FYI
, "In QPathSymLinkInfo (Unix) for path %s\n", searchName
);
2992 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
2997 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
2999 cifs_strtoUTF16((__le16
*) pSMB
->FileName
, searchName
,
3000 PATH_MAX
, nls_codepage
);
3001 name_len
++; /* trailing null */
3003 } else { /* BB improve the check for buffer overruns BB */
3004 name_len
= strnlen(searchName
, PATH_MAX
);
3005 name_len
++; /* trailing null */
3006 strncpy(pSMB
->FileName
, searchName
, name_len
);
3009 params
= 2 /* level */ + 4 /* rsrvd */ + name_len
/* incl null */ ;
3010 pSMB
->TotalDataCount
= 0;
3011 pSMB
->MaxParameterCount
= cpu_to_le16(2);
3012 pSMB
->MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
);
3013 pSMB
->MaxSetupCount
= 0;
3017 pSMB
->Reserved2
= 0;
3018 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
3019 struct smb_com_transaction2_qpi_req
, InformationLevel
) - 4);
3020 pSMB
->DataCount
= 0;
3021 pSMB
->DataOffset
= 0;
3022 pSMB
->SetupCount
= 1;
3023 pSMB
->Reserved3
= 0;
3024 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
3025 byte_count
= params
+ 1 /* pad */ ;
3026 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
3027 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
3028 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK
);
3029 pSMB
->Reserved4
= 0;
3030 inc_rfc1001_len(pSMB
, byte_count
);
3031 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
3033 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3034 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3036 cifs_dbg(FYI
, "Send error in QuerySymLinkInfo = %d\n", rc
);
3038 /* decode response */
3040 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
3041 /* BB also check enough total bytes returned */
3042 if (rc
|| get_bcc(&pSMBr
->hdr
) < 2)
3046 u16 count
= le16_to_cpu(pSMBr
->t2
.DataCount
);
3048 data_start
= ((char *) &pSMBr
->hdr
.Protocol
) +
3049 le16_to_cpu(pSMBr
->t2
.DataOffset
);
3051 if (pSMBr
->hdr
.Flags2
& SMBFLG2_UNICODE
)
3056 /* BB FIXME investigate remapping reserved chars here */
3057 *symlinkinfo
= cifs_strndup_from_utf16(data_start
,
3058 count
, is_unicode
, nls_codepage
);
3063 cifs_buf_release(pSMB
);
3065 goto querySymLinkRetry
;
3070 * Recent Windows versions now create symlinks more frequently
3071 * and they use the "reparse point" mechanism below. We can of course
3072 * do symlinks nicely to Samba and other servers which support the
3073 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3074 * "MF" symlinks optionally, but for recent Windows we really need to
3075 * reenable the code below and fix the cifs_symlink callers to handle this.
3076 * In the interim this code has been moved to its own config option so
3077 * it is not compiled in by default until callers fixed up and more tested.
3080 CIFSSMBQuerySymLink(const unsigned int xid
, struct cifs_tcon
*tcon
,
3081 __u16 fid
, char **symlinkinfo
,
3082 const struct nls_table
*nls_codepage
)
3086 struct smb_com_transaction_ioctl_req
*pSMB
;
3087 struct smb_com_transaction_ioctl_rsp
*pSMBr
;
3089 unsigned int sub_len
;
3091 struct reparse_data
*reparse_buf
;
3092 __u32 data_offset
, data_count
;
3095 cifs_dbg(FYI
, "In Windows reparse style QueryLink for fid %u\n", fid
);
3096 rc
= smb_init(SMB_COM_NT_TRANSACT
, 23, tcon
, (void **) &pSMB
,
3101 pSMB
->TotalParameterCount
= 0 ;
3102 pSMB
->TotalDataCount
= 0;
3103 pSMB
->MaxParameterCount
= cpu_to_le32(2);
3104 /* BB find exact data count max from sess structure BB */
3105 pSMB
->MaxDataCount
= cpu_to_le32(CIFSMaxBufSize
& 0xFFFFFF00);
3106 pSMB
->MaxSetupCount
= 4;
3108 pSMB
->ParameterOffset
= 0;
3109 pSMB
->DataCount
= 0;
3110 pSMB
->DataOffset
= 0;
3111 pSMB
->SetupCount
= 4;
3112 pSMB
->SubCommand
= cpu_to_le16(NT_TRANSACT_IOCTL
);
3113 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
3114 pSMB
->FunctionCode
= cpu_to_le32(FSCTL_GET_REPARSE_POINT
);
3115 pSMB
->IsFsctl
= 1; /* FSCTL */
3116 pSMB
->IsRootFlag
= 0;
3117 pSMB
->Fid
= fid
; /* file handle always le */
3118 pSMB
->ByteCount
= 0;
3120 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3121 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3123 cifs_dbg(FYI
, "Send error in QueryReparseLinkInfo = %d\n", rc
);
3127 data_offset
= le32_to_cpu(pSMBr
->DataOffset
);
3128 data_count
= le32_to_cpu(pSMBr
->DataCount
);
3129 if (get_bcc(&pSMBr
->hdr
) < 2 || data_offset
> 512) {
3130 /* BB also check enough total bytes returned */
3131 rc
= -EIO
; /* bad smb */
3134 if (!data_count
|| (data_count
> 2048)) {
3136 cifs_dbg(FYI
, "Invalid return data count on get reparse info ioctl\n");
3139 end_of_smb
= 2 + get_bcc(&pSMBr
->hdr
) + (char *)&pSMBr
->ByteCount
;
3140 reparse_buf
= (struct reparse_data
*)
3141 ((char *)&pSMBr
->hdr
.Protocol
+ data_offset
);
3142 if ((char *)reparse_buf
>= end_of_smb
) {
3146 if ((reparse_buf
->PathBuffer
+ reparse_buf
->PrintNameOffset
+
3147 reparse_buf
->PrintNameLength
) > end_of_smb
) {
3148 cifs_dbg(FYI
, "reparse buf beyond SMB\n");
3152 sub_start
= reparse_buf
->SubstituteNameOffset
+ reparse_buf
->PathBuffer
;
3153 sub_len
= reparse_buf
->SubstituteNameLength
;
3154 if (pSMBr
->hdr
.Flags2
& SMBFLG2_UNICODE
)
3159 /* BB FIXME investigate remapping reserved chars here */
3160 *symlinkinfo
= cifs_strndup_from_utf16(sub_start
, sub_len
, is_unicode
,
3165 cifs_buf_release(pSMB
);
3168 * Note: On -EAGAIN error only caller can retry on handle based calls
3169 * since file handle passed in no longer valid.
3174 #ifdef CONFIG_CIFS_POSIX
3176 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3177 static void cifs_convert_ace(posix_acl_xattr_entry
*ace
,
3178 struct cifs_posix_ace
*cifs_ace
)
3180 /* u8 cifs fields do not need le conversion */
3181 ace
->e_perm
= cpu_to_le16(cifs_ace
->cifs_e_perm
);
3182 ace
->e_tag
= cpu_to_le16(cifs_ace
->cifs_e_tag
);
3183 ace
->e_id
= cpu_to_le32(le64_to_cpu(cifs_ace
->cifs_uid
));
3185 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3186 ace->e_perm, ace->e_tag, ace->e_id);
3192 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3193 static int cifs_copy_posix_acl(char *trgt
, char *src
, const int buflen
,
3194 const int acl_type
, const int size_of_data_area
)
3199 struct cifs_posix_ace
*pACE
;
3200 struct cifs_posix_acl
*cifs_acl
= (struct cifs_posix_acl
*)src
;
3201 posix_acl_xattr_header
*local_acl
= (posix_acl_xattr_header
*)trgt
;
3203 if (le16_to_cpu(cifs_acl
->version
) != CIFS_ACL_VERSION
)
3206 if (acl_type
& ACL_TYPE_ACCESS
) {
3207 count
= le16_to_cpu(cifs_acl
->access_entry_count
);
3208 pACE
= &cifs_acl
->ace_array
[0];
3209 size
= sizeof(struct cifs_posix_acl
);
3210 size
+= sizeof(struct cifs_posix_ace
) * count
;
3211 /* check if we would go beyond end of SMB */
3212 if (size_of_data_area
< size
) {
3213 cifs_dbg(FYI
, "bad CIFS POSIX ACL size %d vs. %d\n",
3214 size_of_data_area
, size
);
3217 } else if (acl_type
& ACL_TYPE_DEFAULT
) {
3218 count
= le16_to_cpu(cifs_acl
->access_entry_count
);
3219 size
= sizeof(struct cifs_posix_acl
);
3220 size
+= sizeof(struct cifs_posix_ace
) * count
;
3221 /* skip past access ACEs to get to default ACEs */
3222 pACE
= &cifs_acl
->ace_array
[count
];
3223 count
= le16_to_cpu(cifs_acl
->default_entry_count
);
3224 size
+= sizeof(struct cifs_posix_ace
) * count
;
3225 /* check if we would go beyond end of SMB */
3226 if (size_of_data_area
< size
)
3233 size
= posix_acl_xattr_size(count
);
3234 if ((buflen
== 0) || (local_acl
== NULL
)) {
3235 /* used to query ACL EA size */
3236 } else if (size
> buflen
) {
3238 } else /* buffer big enough */ {
3239 local_acl
->a_version
= cpu_to_le32(POSIX_ACL_XATTR_VERSION
);
3240 for (i
= 0; i
< count
; i
++) {
3241 cifs_convert_ace(&local_acl
->a_entries
[i
], pACE
);
3248 static __u16
convert_ace_to_cifs_ace(struct cifs_posix_ace
*cifs_ace
,
3249 const posix_acl_xattr_entry
*local_ace
)
3251 __u16 rc
= 0; /* 0 = ACL converted ok */
3253 cifs_ace
->cifs_e_perm
= le16_to_cpu(local_ace
->e_perm
);
3254 cifs_ace
->cifs_e_tag
= le16_to_cpu(local_ace
->e_tag
);
3255 /* BB is there a better way to handle the large uid? */
3256 if (local_ace
->e_id
== cpu_to_le32(-1)) {
3257 /* Probably no need to le convert -1 on any arch but can not hurt */
3258 cifs_ace
->cifs_uid
= cpu_to_le64(-1);
3260 cifs_ace
->cifs_uid
= cpu_to_le64(le32_to_cpu(local_ace
->e_id
));
3262 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3263 ace->e_perm, ace->e_tag, ace->e_id);
3268 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3269 static __u16
ACL_to_cifs_posix(char *parm_data
, const char *pACL
,
3270 const int buflen
, const int acl_type
)
3273 struct cifs_posix_acl
*cifs_acl
= (struct cifs_posix_acl
*)parm_data
;
3274 posix_acl_xattr_header
*local_acl
= (posix_acl_xattr_header
*)pACL
;
3278 if ((buflen
== 0) || (pACL
== NULL
) || (cifs_acl
== NULL
))
3281 count
= posix_acl_xattr_count((size_t)buflen
);
3282 cifs_dbg(FYI
, "setting acl with %d entries from buf of length %d and version of %d\n",
3283 count
, buflen
, le32_to_cpu(local_acl
->a_version
));
3284 if (le32_to_cpu(local_acl
->a_version
) != 2) {
3285 cifs_dbg(FYI
, "unknown POSIX ACL version %d\n",
3286 le32_to_cpu(local_acl
->a_version
));
3289 cifs_acl
->version
= cpu_to_le16(1);
3290 if (acl_type
== ACL_TYPE_ACCESS
)
3291 cifs_acl
->access_entry_count
= cpu_to_le16(count
);
3292 else if (acl_type
== ACL_TYPE_DEFAULT
)
3293 cifs_acl
->default_entry_count
= cpu_to_le16(count
);
3295 cifs_dbg(FYI
, "unknown ACL type %d\n", acl_type
);
3298 for (i
= 0; i
< count
; i
++) {
3299 rc
= convert_ace_to_cifs_ace(&cifs_acl
->ace_array
[i
],
3300 &local_acl
->a_entries
[i
]);
3302 /* ACE not converted */
3307 rc
= (__u16
)(count
* sizeof(struct cifs_posix_ace
));
3308 rc
+= sizeof(struct cifs_posix_acl
);
3309 /* BB add check to make sure ACL does not overflow SMB */
3315 CIFSSMBGetPosixACL(const unsigned int xid
, struct cifs_tcon
*tcon
,
3316 const unsigned char *searchName
,
3317 char *acl_inf
, const int buflen
, const int acl_type
,
3318 const struct nls_table
*nls_codepage
, int remap
)
3320 /* SMB_QUERY_POSIX_ACL */
3321 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
3322 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
3326 __u16 params
, byte_count
;
3328 cifs_dbg(FYI
, "In GetPosixACL (Unix) for path %s\n", searchName
);
3331 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
3336 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
3338 cifsConvertToUTF16((__le16
*) pSMB
->FileName
,
3339 searchName
, PATH_MAX
, nls_codepage
,
3341 name_len
++; /* trailing null */
3343 pSMB
->FileName
[name_len
] = 0;
3344 pSMB
->FileName
[name_len
+1] = 0;
3345 } else { /* BB improve the check for buffer overruns BB */
3346 name_len
= strnlen(searchName
, PATH_MAX
);
3347 name_len
++; /* trailing null */
3348 strncpy(pSMB
->FileName
, searchName
, name_len
);
3351 params
= 2 /* level */ + 4 /* rsrvd */ + name_len
/* incl null */ ;
3352 pSMB
->TotalDataCount
= 0;
3353 pSMB
->MaxParameterCount
= cpu_to_le16(2);
3354 /* BB find exact max data count below from sess structure BB */
3355 pSMB
->MaxDataCount
= cpu_to_le16(4000);
3356 pSMB
->MaxSetupCount
= 0;
3360 pSMB
->Reserved2
= 0;
3361 pSMB
->ParameterOffset
= cpu_to_le16(
3362 offsetof(struct smb_com_transaction2_qpi_req
,
3363 InformationLevel
) - 4);
3364 pSMB
->DataCount
= 0;
3365 pSMB
->DataOffset
= 0;
3366 pSMB
->SetupCount
= 1;
3367 pSMB
->Reserved3
= 0;
3368 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
3369 byte_count
= params
+ 1 /* pad */ ;
3370 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
3371 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
3372 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_POSIX_ACL
);
3373 pSMB
->Reserved4
= 0;
3374 inc_rfc1001_len(pSMB
, byte_count
);
3375 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
3377 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3378 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3379 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_acl_get
);
3381 cifs_dbg(FYI
, "Send error in Query POSIX ACL = %d\n", rc
);
3383 /* decode response */
3385 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
3386 /* BB also check enough total bytes returned */
3387 if (rc
|| get_bcc(&pSMBr
->hdr
) < 2)
3388 rc
= -EIO
; /* bad smb */
3390 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
3391 __u16 count
= le16_to_cpu(pSMBr
->t2
.DataCount
);
3392 rc
= cifs_copy_posix_acl(acl_inf
,
3393 (char *)&pSMBr
->hdr
.Protocol
+data_offset
,
3394 buflen
, acl_type
, count
);
3397 cifs_buf_release(pSMB
);
3404 CIFSSMBSetPosixACL(const unsigned int xid
, struct cifs_tcon
*tcon
,
3405 const unsigned char *fileName
,
3406 const char *local_acl
, const int buflen
,
3408 const struct nls_table
*nls_codepage
, int remap
)
3410 struct smb_com_transaction2_spi_req
*pSMB
= NULL
;
3411 struct smb_com_transaction2_spi_rsp
*pSMBr
= NULL
;
3415 int bytes_returned
= 0;
3416 __u16 params
, byte_count
, data_count
, param_offset
, offset
;
3418 cifs_dbg(FYI
, "In SetPosixACL (Unix) for path %s\n", fileName
);
3420 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
3424 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
3426 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, fileName
,
3427 PATH_MAX
, nls_codepage
, remap
);
3428 name_len
++; /* trailing null */
3430 } else { /* BB improve the check for buffer overruns BB */
3431 name_len
= strnlen(fileName
, PATH_MAX
);
3432 name_len
++; /* trailing null */
3433 strncpy(pSMB
->FileName
, fileName
, name_len
);
3435 params
= 6 + name_len
;
3436 pSMB
->MaxParameterCount
= cpu_to_le16(2);
3437 /* BB find max SMB size from sess */
3438 pSMB
->MaxDataCount
= cpu_to_le16(1000);
3439 pSMB
->MaxSetupCount
= 0;
3443 pSMB
->Reserved2
= 0;
3444 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
3445 InformationLevel
) - 4;
3446 offset
= param_offset
+ params
;
3447 parm_data
= ((char *) &pSMB
->hdr
.Protocol
) + offset
;
3448 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
3450 /* convert to on the wire format for POSIX ACL */
3451 data_count
= ACL_to_cifs_posix(parm_data
, local_acl
, buflen
, acl_type
);
3453 if (data_count
== 0) {
3455 goto setACLerrorExit
;
3457 pSMB
->DataOffset
= cpu_to_le16(offset
);
3458 pSMB
->SetupCount
= 1;
3459 pSMB
->Reserved3
= 0;
3460 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
3461 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_POSIX_ACL
);
3462 byte_count
= 3 /* pad */ + params
+ data_count
;
3463 pSMB
->DataCount
= cpu_to_le16(data_count
);
3464 pSMB
->TotalDataCount
= pSMB
->DataCount
;
3465 pSMB
->ParameterCount
= cpu_to_le16(params
);
3466 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
3467 pSMB
->Reserved4
= 0;
3468 inc_rfc1001_len(pSMB
, byte_count
);
3469 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
3470 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3471 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3473 cifs_dbg(FYI
, "Set POSIX ACL returned %d\n", rc
);
3476 cifs_buf_release(pSMB
);
3482 /* BB fix tabs in this function FIXME BB */
3484 CIFSGetExtAttr(const unsigned int xid
, struct cifs_tcon
*tcon
,
3485 const int netfid
, __u64
*pExtAttrBits
, __u64
*pMask
)
3488 struct smb_t2_qfi_req
*pSMB
= NULL
;
3489 struct smb_t2_qfi_rsp
*pSMBr
= NULL
;
3491 __u16 params
, byte_count
;
3493 cifs_dbg(FYI
, "In GetExtAttr\n");
3498 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
3503 params
= 2 /* level */ + 2 /* fid */;
3504 pSMB
->t2
.TotalDataCount
= 0;
3505 pSMB
->t2
.MaxParameterCount
= cpu_to_le16(4);
3506 /* BB find exact max data count below from sess structure BB */
3507 pSMB
->t2
.MaxDataCount
= cpu_to_le16(4000);
3508 pSMB
->t2
.MaxSetupCount
= 0;
3509 pSMB
->t2
.Reserved
= 0;
3511 pSMB
->t2
.Timeout
= 0;
3512 pSMB
->t2
.Reserved2
= 0;
3513 pSMB
->t2
.ParameterOffset
= cpu_to_le16(offsetof(struct smb_t2_qfi_req
,
3515 pSMB
->t2
.DataCount
= 0;
3516 pSMB
->t2
.DataOffset
= 0;
3517 pSMB
->t2
.SetupCount
= 1;
3518 pSMB
->t2
.Reserved3
= 0;
3519 pSMB
->t2
.SubCommand
= cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION
);
3520 byte_count
= params
+ 1 /* pad */ ;
3521 pSMB
->t2
.TotalParameterCount
= cpu_to_le16(params
);
3522 pSMB
->t2
.ParameterCount
= pSMB
->t2
.TotalParameterCount
;
3523 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_ATTR_FLAGS
);
3526 inc_rfc1001_len(pSMB
, byte_count
);
3527 pSMB
->t2
.ByteCount
= cpu_to_le16(byte_count
);
3529 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3530 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3532 cifs_dbg(FYI
, "error %d in GetExtAttr\n", rc
);
3534 /* decode response */
3535 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
3536 /* BB also check enough total bytes returned */
3537 if (rc
|| get_bcc(&pSMBr
->hdr
) < 2)
3538 /* If rc should we check for EOPNOSUPP and
3539 disable the srvino flag? or in caller? */
3540 rc
= -EIO
; /* bad smb */
3542 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
3543 __u16 count
= le16_to_cpu(pSMBr
->t2
.DataCount
);
3544 struct file_chattr_info
*pfinfo
;
3545 /* BB Do we need a cast or hash here ? */
3547 cifs_dbg(FYI
, "Illegal size ret in GetExtAttr\n");
3551 pfinfo
= (struct file_chattr_info
*)
3552 (data_offset
+ (char *) &pSMBr
->hdr
.Protocol
);
3553 *pExtAttrBits
= le64_to_cpu(pfinfo
->mode
);
3554 *pMask
= le64_to_cpu(pfinfo
->mask
);
3558 cifs_buf_release(pSMB
);
3560 goto GetExtAttrRetry
;
3564 #endif /* CONFIG_POSIX */
3566 #ifdef CONFIG_CIFS_ACL
3568 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3569 * all NT TRANSACTS that we init here have total parm and data under about 400
3570 * bytes (to fit in small cifs buffer size), which is the case so far, it
3571 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3572 * returned setup area) and MaxParameterCount (returned parms size) must be set
3576 smb_init_nttransact(const __u16 sub_command
, const int setup_count
,
3577 const int parm_len
, struct cifs_tcon
*tcon
,
3582 struct smb_com_ntransact_req
*pSMB
;
3584 rc
= small_smb_init(SMB_COM_NT_TRANSACT
, 19 + setup_count
, tcon
,
3588 *ret_buf
= (void *)pSMB
;
3590 pSMB
->TotalParameterCount
= cpu_to_le32(parm_len
);
3591 pSMB
->TotalDataCount
= 0;
3592 pSMB
->MaxDataCount
= cpu_to_le32(CIFSMaxBufSize
& 0xFFFFFF00);
3593 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
3594 pSMB
->DataCount
= pSMB
->TotalDataCount
;
3595 temp_offset
= offsetof(struct smb_com_ntransact_req
, Parms
) +
3596 (setup_count
* 2) - 4 /* for rfc1001 length itself */;
3597 pSMB
->ParameterOffset
= cpu_to_le32(temp_offset
);
3598 pSMB
->DataOffset
= cpu_to_le32(temp_offset
+ parm_len
);
3599 pSMB
->SetupCount
= setup_count
; /* no need to le convert byte fields */
3600 pSMB
->SubCommand
= cpu_to_le16(sub_command
);
3605 validate_ntransact(char *buf
, char **ppparm
, char **ppdata
,
3606 __u32
*pparmlen
, __u32
*pdatalen
)
3609 __u32 data_count
, data_offset
, parm_count
, parm_offset
;
3610 struct smb_com_ntransact_rsp
*pSMBr
;
3619 pSMBr
= (struct smb_com_ntransact_rsp
*)buf
;
3621 bcc
= get_bcc(&pSMBr
->hdr
);
3622 end_of_smb
= 2 /* sizeof byte count */ + bcc
+
3623 (char *)&pSMBr
->ByteCount
;
3625 data_offset
= le32_to_cpu(pSMBr
->DataOffset
);
3626 data_count
= le32_to_cpu(pSMBr
->DataCount
);
3627 parm_offset
= le32_to_cpu(pSMBr
->ParameterOffset
);
3628 parm_count
= le32_to_cpu(pSMBr
->ParameterCount
);
3630 *ppparm
= (char *)&pSMBr
->hdr
.Protocol
+ parm_offset
;
3631 *ppdata
= (char *)&pSMBr
->hdr
.Protocol
+ data_offset
;
3633 /* should we also check that parm and data areas do not overlap? */
3634 if (*ppparm
> end_of_smb
) {
3635 cifs_dbg(FYI
, "parms start after end of smb\n");
3637 } else if (parm_count
+ *ppparm
> end_of_smb
) {
3638 cifs_dbg(FYI
, "parm end after end of smb\n");
3640 } else if (*ppdata
> end_of_smb
) {
3641 cifs_dbg(FYI
, "data starts after end of smb\n");
3643 } else if (data_count
+ *ppdata
> end_of_smb
) {
3644 cifs_dbg(FYI
, "data %p + count %d (%p) past smb end %p start %p\n",
3645 *ppdata
, data_count
, (data_count
+ *ppdata
),
3648 } else if (parm_count
+ data_count
> bcc
) {
3649 cifs_dbg(FYI
, "parm count and data count larger than SMB\n");
3652 *pdatalen
= data_count
;
3653 *pparmlen
= parm_count
;
3657 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3659 CIFSSMBGetCIFSACL(const unsigned int xid
, struct cifs_tcon
*tcon
, __u16 fid
,
3660 struct cifs_ntsd
**acl_inf
, __u32
*pbuflen
)
3664 QUERY_SEC_DESC_REQ
*pSMB
;
3667 cifs_dbg(FYI
, "GetCifsACL\n");
3672 rc
= smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC
, 0,
3673 8 /* parm len */, tcon
, (void **) &pSMB
);
3677 pSMB
->MaxParameterCount
= cpu_to_le32(4);
3678 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3679 pSMB
->MaxSetupCount
= 0;
3680 pSMB
->Fid
= fid
; /* file handle always le */
3681 pSMB
->AclFlags
= cpu_to_le32(CIFS_ACL_OWNER
| CIFS_ACL_GROUP
|
3683 pSMB
->ByteCount
= cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3684 inc_rfc1001_len(pSMB
, 11);
3685 iov
[0].iov_base
= (char *)pSMB
;
3686 iov
[0].iov_len
= be32_to_cpu(pSMB
->hdr
.smb_buf_length
) + 4;
3688 rc
= SendReceive2(xid
, tcon
->ses
, iov
, 1 /* num iovec */, &buf_type
,
3690 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_acl_get
);
3692 cifs_dbg(FYI
, "Send error in QuerySecDesc = %d\n", rc
);
3693 } else { /* decode response */
3697 struct smb_com_ntransact_rsp
*pSMBr
;
3700 /* validate_nttransact */
3701 rc
= validate_ntransact(iov
[0].iov_base
, (char **)&parm
,
3702 &pdata
, &parm_len
, pbuflen
);
3705 pSMBr
= (struct smb_com_ntransact_rsp
*)iov
[0].iov_base
;
3707 cifs_dbg(FYI
, "smb %p parm %p data %p\n",
3708 pSMBr
, parm
, *acl_inf
);
3710 if (le32_to_cpu(pSMBr
->ParameterCount
) != 4) {
3711 rc
= -EIO
; /* bad smb */
3716 /* BB check that data area is minimum length and as big as acl_len */
3718 acl_len
= le32_to_cpu(*parm
);
3719 if (acl_len
!= *pbuflen
) {
3720 cifs_dbg(VFS
, "acl length %d does not match %d\n",
3722 if (*pbuflen
> acl_len
)
3726 /* check if buffer is big enough for the acl
3727 header followed by the smallest SID */
3728 if ((*pbuflen
< sizeof(struct cifs_ntsd
) + 8) ||
3729 (*pbuflen
>= 64 * 1024)) {
3730 cifs_dbg(VFS
, "bad acl length %d\n", *pbuflen
);
3734 *acl_inf
= kmemdup(pdata
, *pbuflen
, GFP_KERNEL
);
3735 if (*acl_inf
== NULL
) {
3742 if (buf_type
== CIFS_SMALL_BUFFER
)
3743 cifs_small_buf_release(iov
[0].iov_base
);
3744 else if (buf_type
== CIFS_LARGE_BUFFER
)
3745 cifs_buf_release(iov
[0].iov_base
);
3746 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3751 CIFSSMBSetCIFSACL(const unsigned int xid
, struct cifs_tcon
*tcon
, __u16 fid
,
3752 struct cifs_ntsd
*pntsd
, __u32 acllen
, int aclflag
)
3754 __u16 byte_count
, param_count
, data_count
, param_offset
, data_offset
;
3756 int bytes_returned
= 0;
3757 SET_SEC_DESC_REQ
*pSMB
= NULL
;
3761 rc
= smb_init(SMB_COM_NT_TRANSACT
, 19, tcon
, (void **) &pSMB
, &pSMBr
);
3765 pSMB
->MaxSetupCount
= 0;
3769 param_offset
= offsetof(struct smb_com_transaction_ssec_req
, Fid
) - 4;
3770 data_count
= acllen
;
3771 data_offset
= param_offset
+ param_count
;
3772 byte_count
= 3 /* pad */ + param_count
;
3774 pSMB
->DataCount
= cpu_to_le32(data_count
);
3775 pSMB
->TotalDataCount
= pSMB
->DataCount
;
3776 pSMB
->MaxParameterCount
= cpu_to_le32(4);
3777 pSMB
->MaxDataCount
= cpu_to_le32(16384);
3778 pSMB
->ParameterCount
= cpu_to_le32(param_count
);
3779 pSMB
->ParameterOffset
= cpu_to_le32(param_offset
);
3780 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
3781 pSMB
->DataOffset
= cpu_to_le32(data_offset
);
3782 pSMB
->SetupCount
= 0;
3783 pSMB
->SubCommand
= cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC
);
3784 pSMB
->ByteCount
= cpu_to_le16(byte_count
+data_count
);
3786 pSMB
->Fid
= fid
; /* file handle always le */
3787 pSMB
->Reserved2
= 0;
3788 pSMB
->AclFlags
= cpu_to_le32(aclflag
);
3790 if (pntsd
&& acllen
) {
3791 memcpy((char *)pSMBr
+ offsetof(struct smb_hdr
, Protocol
) +
3792 data_offset
, pntsd
, acllen
);
3793 inc_rfc1001_len(pSMB
, byte_count
+ data_count
);
3795 inc_rfc1001_len(pSMB
, byte_count
);
3797 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3798 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3800 cifs_dbg(FYI
, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3801 bytes_returned
, rc
);
3803 cifs_dbg(FYI
, "Set CIFS ACL returned %d\n", rc
);
3804 cifs_buf_release(pSMB
);
3807 goto setCifsAclRetry
;
3812 #endif /* CONFIG_CIFS_ACL */
3814 /* Legacy Query Path Information call for lookup to old servers such
3817 SMBQueryInformation(const unsigned int xid
, struct cifs_tcon
*tcon
,
3818 const char *search_name
, FILE_ALL_INFO
*data
,
3819 const struct nls_table
*nls_codepage
, int remap
)
3821 QUERY_INFORMATION_REQ
*pSMB
;
3822 QUERY_INFORMATION_RSP
*pSMBr
;
3827 cifs_dbg(FYI
, "In SMBQPath path %s\n", search_name
);
3829 rc
= smb_init(SMB_COM_QUERY_INFORMATION
, 0, tcon
, (void **) &pSMB
,
3834 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
3836 cifsConvertToUTF16((__le16
*) pSMB
->FileName
,
3837 search_name
, PATH_MAX
, nls_codepage
,
3839 name_len
++; /* trailing null */
3842 name_len
= strnlen(search_name
, PATH_MAX
);
3843 name_len
++; /* trailing null */
3844 strncpy(pSMB
->FileName
, search_name
, name_len
);
3846 pSMB
->BufferFormat
= 0x04;
3847 name_len
++; /* account for buffer type byte */
3848 inc_rfc1001_len(pSMB
, (__u16
)name_len
);
3849 pSMB
->ByteCount
= cpu_to_le16(name_len
);
3851 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3852 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3854 cifs_dbg(FYI
, "Send error in QueryInfo = %d\n", rc
);
3857 __u32 time
= le32_to_cpu(pSMBr
->last_write_time
);
3859 /* decode response */
3860 /* BB FIXME - add time zone adjustment BB */
3861 memset(data
, 0, sizeof(FILE_ALL_INFO
));
3864 /* decode time fields */
3865 data
->ChangeTime
= cpu_to_le64(cifs_UnixTimeToNT(ts
));
3866 data
->LastWriteTime
= data
->ChangeTime
;
3867 data
->LastAccessTime
= 0;
3868 data
->AllocationSize
=
3869 cpu_to_le64(le32_to_cpu(pSMBr
->size
));
3870 data
->EndOfFile
= data
->AllocationSize
;
3872 cpu_to_le32(le16_to_cpu(pSMBr
->attr
));
3874 rc
= -EIO
; /* bad buffer passed in */
3876 cifs_buf_release(pSMB
);
3885 CIFSSMBQFileInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
3886 u16 netfid
, FILE_ALL_INFO
*pFindData
)
3888 struct smb_t2_qfi_req
*pSMB
= NULL
;
3889 struct smb_t2_qfi_rsp
*pSMBr
= NULL
;
3892 __u16 params
, byte_count
;
3895 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
3900 params
= 2 /* level */ + 2 /* fid */;
3901 pSMB
->t2
.TotalDataCount
= 0;
3902 pSMB
->t2
.MaxParameterCount
= cpu_to_le16(4);
3903 /* BB find exact max data count below from sess structure BB */
3904 pSMB
->t2
.MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
);
3905 pSMB
->t2
.MaxSetupCount
= 0;
3906 pSMB
->t2
.Reserved
= 0;
3908 pSMB
->t2
.Timeout
= 0;
3909 pSMB
->t2
.Reserved2
= 0;
3910 pSMB
->t2
.ParameterOffset
= cpu_to_le16(offsetof(struct smb_t2_qfi_req
,
3912 pSMB
->t2
.DataCount
= 0;
3913 pSMB
->t2
.DataOffset
= 0;
3914 pSMB
->t2
.SetupCount
= 1;
3915 pSMB
->t2
.Reserved3
= 0;
3916 pSMB
->t2
.SubCommand
= cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION
);
3917 byte_count
= params
+ 1 /* pad */ ;
3918 pSMB
->t2
.TotalParameterCount
= cpu_to_le16(params
);
3919 pSMB
->t2
.ParameterCount
= pSMB
->t2
.TotalParameterCount
;
3920 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_ALL_INFO
);
3923 inc_rfc1001_len(pSMB
, byte_count
);
3924 pSMB
->t2
.ByteCount
= cpu_to_le16(byte_count
);
3926 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
3927 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
3929 cifs_dbg(FYI
, "Send error in QPathInfo = %d\n", rc
);
3930 } else { /* decode response */
3931 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
3933 if (rc
) /* BB add auto retry on EOPNOTSUPP? */
3935 else if (get_bcc(&pSMBr
->hdr
) < 40)
3936 rc
= -EIO
; /* bad smb */
3937 else if (pFindData
) {
3938 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
3939 memcpy((char *) pFindData
,
3940 (char *) &pSMBr
->hdr
.Protocol
+
3941 data_offset
, sizeof(FILE_ALL_INFO
));
3945 cifs_buf_release(pSMB
);
3947 goto QFileInfoRetry
;
3953 CIFSSMBQPathInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
3954 const char *search_name
, FILE_ALL_INFO
*data
,
3955 int legacy
/* old style infolevel */,
3956 const struct nls_table
*nls_codepage
, int remap
)
3958 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3959 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
3960 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
3964 __u16 params
, byte_count
;
3966 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
3968 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
3973 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
3975 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, search_name
,
3976 PATH_MAX
, nls_codepage
, remap
);
3977 name_len
++; /* trailing null */
3979 } else { /* BB improve the check for buffer overruns BB */
3980 name_len
= strnlen(search_name
, PATH_MAX
);
3981 name_len
++; /* trailing null */
3982 strncpy(pSMB
->FileName
, search_name
, name_len
);
3985 params
= 2 /* level */ + 4 /* reserved */ + name_len
/* includes NUL */;
3986 pSMB
->TotalDataCount
= 0;
3987 pSMB
->MaxParameterCount
= cpu_to_le16(2);
3988 /* BB find exact max SMB PDU from sess structure BB */
3989 pSMB
->MaxDataCount
= cpu_to_le16(4000);
3990 pSMB
->MaxSetupCount
= 0;
3994 pSMB
->Reserved2
= 0;
3995 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
3996 struct smb_com_transaction2_qpi_req
, InformationLevel
) - 4);
3997 pSMB
->DataCount
= 0;
3998 pSMB
->DataOffset
= 0;
3999 pSMB
->SetupCount
= 1;
4000 pSMB
->Reserved3
= 0;
4001 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
4002 byte_count
= params
+ 1 /* pad */ ;
4003 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4004 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4006 pSMB
->InformationLevel
= cpu_to_le16(SMB_INFO_STANDARD
);
4008 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_ALL_INFO
);
4009 pSMB
->Reserved4
= 0;
4010 inc_rfc1001_len(pSMB
, byte_count
);
4011 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4013 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4014 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4016 cifs_dbg(FYI
, "Send error in QPathInfo = %d\n", rc
);
4017 } else { /* decode response */
4018 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4020 if (rc
) /* BB add auto retry on EOPNOTSUPP? */
4022 else if (!legacy
&& get_bcc(&pSMBr
->hdr
) < 40)
4023 rc
= -EIO
; /* bad smb */
4024 else if (legacy
&& get_bcc(&pSMBr
->hdr
) < 24)
4025 rc
= -EIO
; /* 24 or 26 expected but we do not read
4029 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4032 * On legacy responses we do not read the last field,
4033 * EAsize, fortunately since it varies by subdialect and
4034 * also note it differs on Set vs Get, ie two bytes or 4
4035 * bytes depending but we don't care here.
4038 size
= sizeof(FILE_INFO_STANDARD
);
4040 size
= sizeof(FILE_ALL_INFO
);
4041 memcpy((char *) data
, (char *) &pSMBr
->hdr
.Protocol
+
4046 cifs_buf_release(pSMB
);
4048 goto QPathInfoRetry
;
4054 CIFSSMBUnixQFileInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
4055 u16 netfid
, FILE_UNIX_BASIC_INFO
*pFindData
)
4057 struct smb_t2_qfi_req
*pSMB
= NULL
;
4058 struct smb_t2_qfi_rsp
*pSMBr
= NULL
;
4061 __u16 params
, byte_count
;
4064 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4069 params
= 2 /* level */ + 2 /* fid */;
4070 pSMB
->t2
.TotalDataCount
= 0;
4071 pSMB
->t2
.MaxParameterCount
= cpu_to_le16(4);
4072 /* BB find exact max data count below from sess structure BB */
4073 pSMB
->t2
.MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
);
4074 pSMB
->t2
.MaxSetupCount
= 0;
4075 pSMB
->t2
.Reserved
= 0;
4077 pSMB
->t2
.Timeout
= 0;
4078 pSMB
->t2
.Reserved2
= 0;
4079 pSMB
->t2
.ParameterOffset
= cpu_to_le16(offsetof(struct smb_t2_qfi_req
,
4081 pSMB
->t2
.DataCount
= 0;
4082 pSMB
->t2
.DataOffset
= 0;
4083 pSMB
->t2
.SetupCount
= 1;
4084 pSMB
->t2
.Reserved3
= 0;
4085 pSMB
->t2
.SubCommand
= cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION
);
4086 byte_count
= params
+ 1 /* pad */ ;
4087 pSMB
->t2
.TotalParameterCount
= cpu_to_le16(params
);
4088 pSMB
->t2
.ParameterCount
= pSMB
->t2
.TotalParameterCount
;
4089 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC
);
4092 inc_rfc1001_len(pSMB
, byte_count
);
4093 pSMB
->t2
.ByteCount
= cpu_to_le16(byte_count
);
4095 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4096 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4098 cifs_dbg(FYI
, "Send error in QPathInfo = %d\n", rc
);
4099 } else { /* decode response */
4100 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4102 if (rc
|| get_bcc(&pSMBr
->hdr
) < sizeof(FILE_UNIX_BASIC_INFO
)) {
4103 cifs_dbg(VFS
, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4104 rc
= -EIO
; /* bad smb */
4106 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4107 memcpy((char *) pFindData
,
4108 (char *) &pSMBr
->hdr
.Protocol
+
4110 sizeof(FILE_UNIX_BASIC_INFO
));
4114 cifs_buf_release(pSMB
);
4116 goto UnixQFileInfoRetry
;
4122 CIFSSMBUnixQPathInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
4123 const unsigned char *searchName
,
4124 FILE_UNIX_BASIC_INFO
*pFindData
,
4125 const struct nls_table
*nls_codepage
, int remap
)
4127 /* SMB_QUERY_FILE_UNIX_BASIC */
4128 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
4129 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
4131 int bytes_returned
= 0;
4133 __u16 params
, byte_count
;
4135 cifs_dbg(FYI
, "In QPathInfo (Unix) the path %s\n", searchName
);
4137 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4142 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
4144 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, searchName
,
4145 PATH_MAX
, nls_codepage
, remap
);
4146 name_len
++; /* trailing null */
4148 } else { /* BB improve the check for buffer overruns BB */
4149 name_len
= strnlen(searchName
, PATH_MAX
);
4150 name_len
++; /* trailing null */
4151 strncpy(pSMB
->FileName
, searchName
, name_len
);
4154 params
= 2 /* level */ + 4 /* reserved */ + name_len
/* includes NUL */;
4155 pSMB
->TotalDataCount
= 0;
4156 pSMB
->MaxParameterCount
= cpu_to_le16(2);
4157 /* BB find exact max SMB PDU from sess structure BB */
4158 pSMB
->MaxDataCount
= cpu_to_le16(4000);
4159 pSMB
->MaxSetupCount
= 0;
4163 pSMB
->Reserved2
= 0;
4164 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
4165 struct smb_com_transaction2_qpi_req
, InformationLevel
) - 4);
4166 pSMB
->DataCount
= 0;
4167 pSMB
->DataOffset
= 0;
4168 pSMB
->SetupCount
= 1;
4169 pSMB
->Reserved3
= 0;
4170 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
4171 byte_count
= params
+ 1 /* pad */ ;
4172 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4173 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4174 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC
);
4175 pSMB
->Reserved4
= 0;
4176 inc_rfc1001_len(pSMB
, byte_count
);
4177 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4179 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4180 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4182 cifs_dbg(FYI
, "Send error in QPathInfo = %d\n", rc
);
4183 } else { /* decode response */
4184 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4186 if (rc
|| get_bcc(&pSMBr
->hdr
) < sizeof(FILE_UNIX_BASIC_INFO
)) {
4187 cifs_dbg(VFS
, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4188 rc
= -EIO
; /* bad smb */
4190 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4191 memcpy((char *) pFindData
,
4192 (char *) &pSMBr
->hdr
.Protocol
+
4194 sizeof(FILE_UNIX_BASIC_INFO
));
4197 cifs_buf_release(pSMB
);
4199 goto UnixQPathInfoRetry
;
4204 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4206 CIFSFindFirst(const unsigned int xid
, struct cifs_tcon
*tcon
,
4207 const char *searchName
, struct cifs_sb_info
*cifs_sb
,
4208 __u16
*pnetfid
, __u16 search_flags
,
4209 struct cifs_search_info
*psrch_inf
, bool msearch
)
4211 /* level 257 SMB_ */
4212 TRANSACTION2_FFIRST_REQ
*pSMB
= NULL
;
4213 TRANSACTION2_FFIRST_RSP
*pSMBr
= NULL
;
4214 T2_FFIRST_RSP_PARMS
*parms
;
4216 int bytes_returned
= 0;
4217 int name_len
, remap
;
4218 __u16 params
, byte_count
;
4219 struct nls_table
*nls_codepage
;
4221 cifs_dbg(FYI
, "In FindFirst for %s\n", searchName
);
4224 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4229 nls_codepage
= cifs_sb
->local_nls
;
4230 remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
4232 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
4234 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, searchName
,
4235 PATH_MAX
, nls_codepage
, remap
);
4236 /* We can not add the asterik earlier in case
4237 it got remapped to 0xF03A as if it were part of the
4238 directory name instead of a wildcard */
4241 pSMB
->FileName
[name_len
] = CIFS_DIR_SEP(cifs_sb
);
4242 pSMB
->FileName
[name_len
+1] = 0;
4243 pSMB
->FileName
[name_len
+2] = '*';
4244 pSMB
->FileName
[name_len
+3] = 0;
4245 name_len
+= 4; /* now the trailing null */
4246 /* null terminate just in case */
4247 pSMB
->FileName
[name_len
] = 0;
4248 pSMB
->FileName
[name_len
+1] = 0;
4251 } else { /* BB add check for overrun of SMB buf BB */
4252 name_len
= strnlen(searchName
, PATH_MAX
);
4253 /* BB fix here and in unicode clause above ie
4254 if (name_len > buffersize-header)
4255 free buffer exit; BB */
4256 strncpy(pSMB
->FileName
, searchName
, name_len
);
4258 pSMB
->FileName
[name_len
] = CIFS_DIR_SEP(cifs_sb
);
4259 pSMB
->FileName
[name_len
+1] = '*';
4260 pSMB
->FileName
[name_len
+2] = 0;
4265 params
= 12 + name_len
/* includes null */ ;
4266 pSMB
->TotalDataCount
= 0; /* no EAs */
4267 pSMB
->MaxParameterCount
= cpu_to_le16(10);
4268 pSMB
->MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
& 0xFFFFFF00);
4269 pSMB
->MaxSetupCount
= 0;
4273 pSMB
->Reserved2
= 0;
4274 byte_count
= params
+ 1 /* pad */ ;
4275 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4276 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4277 pSMB
->ParameterOffset
= cpu_to_le16(
4278 offsetof(struct smb_com_transaction2_ffirst_req
, SearchAttributes
)
4280 pSMB
->DataCount
= 0;
4281 pSMB
->DataOffset
= 0;
4282 pSMB
->SetupCount
= 1; /* one byte, no need to make endian neutral */
4283 pSMB
->Reserved3
= 0;
4284 pSMB
->SubCommand
= cpu_to_le16(TRANS2_FIND_FIRST
);
4285 pSMB
->SearchAttributes
=
4286 cpu_to_le16(ATTR_READONLY
| ATTR_HIDDEN
| ATTR_SYSTEM
|
4288 pSMB
->SearchCount
= cpu_to_le16(CIFSMaxBufSize
/sizeof(FILE_UNIX_INFO
));
4289 pSMB
->SearchFlags
= cpu_to_le16(search_flags
);
4290 pSMB
->InformationLevel
= cpu_to_le16(psrch_inf
->info_level
);
4292 /* BB what should we set StorageType to? Does it matter? BB */
4293 pSMB
->SearchStorageType
= 0;
4294 inc_rfc1001_len(pSMB
, byte_count
);
4295 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4297 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4298 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4299 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_ffirst
);
4301 if (rc
) {/* BB add logic to retry regular search if Unix search
4302 rejected unexpectedly by server */
4303 /* BB Add code to handle unsupported level rc */
4304 cifs_dbg(FYI
, "Error in FindFirst = %d\n", rc
);
4306 cifs_buf_release(pSMB
);
4308 /* BB eventually could optimize out free and realloc of buf */
4311 goto findFirstRetry
;
4312 } else { /* decode response */
4313 /* BB remember to free buffer if error BB */
4314 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4318 if (pSMBr
->hdr
.Flags2
& SMBFLG2_UNICODE
)
4319 psrch_inf
->unicode
= true;
4321 psrch_inf
->unicode
= false;
4323 psrch_inf
->ntwrk_buf_start
= (char *)pSMBr
;
4324 psrch_inf
->smallBuf
= 0;
4325 psrch_inf
->srch_entries_start
=
4326 (char *) &pSMBr
->hdr
.Protocol
+
4327 le16_to_cpu(pSMBr
->t2
.DataOffset
);
4328 parms
= (T2_FFIRST_RSP_PARMS
*)((char *) &pSMBr
->hdr
.Protocol
+
4329 le16_to_cpu(pSMBr
->t2
.ParameterOffset
));
4331 if (parms
->EndofSearch
)
4332 psrch_inf
->endOfSearch
= true;
4334 psrch_inf
->endOfSearch
= false;
4336 psrch_inf
->entries_in_buffer
=
4337 le16_to_cpu(parms
->SearchCount
);
4338 psrch_inf
->index_of_last_entry
= 2 /* skip . and .. */ +
4339 psrch_inf
->entries_in_buffer
;
4340 lnoff
= le16_to_cpu(parms
->LastNameOffset
);
4341 if (CIFSMaxBufSize
< lnoff
) {
4342 cifs_dbg(VFS
, "ignoring corrupt resume name\n");
4343 psrch_inf
->last_entry
= NULL
;
4347 psrch_inf
->last_entry
= psrch_inf
->srch_entries_start
+
4351 *pnetfid
= parms
->SearchHandle
;
4353 cifs_buf_release(pSMB
);
4360 int CIFSFindNext(const unsigned int xid
, struct cifs_tcon
*tcon
,
4361 __u16 searchHandle
, __u16 search_flags
,
4362 struct cifs_search_info
*psrch_inf
)
4364 TRANSACTION2_FNEXT_REQ
*pSMB
= NULL
;
4365 TRANSACTION2_FNEXT_RSP
*pSMBr
= NULL
;
4366 T2_FNEXT_RSP_PARMS
*parms
;
4367 char *response_data
;
4370 unsigned int name_len
;
4371 __u16 params
, byte_count
;
4373 cifs_dbg(FYI
, "In FindNext\n");
4375 if (psrch_inf
->endOfSearch
)
4378 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4383 params
= 14; /* includes 2 bytes of null string, converted to LE below*/
4385 pSMB
->TotalDataCount
= 0; /* no EAs */
4386 pSMB
->MaxParameterCount
= cpu_to_le16(8);
4387 pSMB
->MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
& 0xFFFFFF00);
4388 pSMB
->MaxSetupCount
= 0;
4392 pSMB
->Reserved2
= 0;
4393 pSMB
->ParameterOffset
= cpu_to_le16(
4394 offsetof(struct smb_com_transaction2_fnext_req
,SearchHandle
) - 4);
4395 pSMB
->DataCount
= 0;
4396 pSMB
->DataOffset
= 0;
4397 pSMB
->SetupCount
= 1;
4398 pSMB
->Reserved3
= 0;
4399 pSMB
->SubCommand
= cpu_to_le16(TRANS2_FIND_NEXT
);
4400 pSMB
->SearchHandle
= searchHandle
; /* always kept as le */
4402 cpu_to_le16(CIFSMaxBufSize
/ sizeof(FILE_UNIX_INFO
));
4403 pSMB
->InformationLevel
= cpu_to_le16(psrch_inf
->info_level
);
4404 pSMB
->ResumeKey
= psrch_inf
->resume_key
;
4405 pSMB
->SearchFlags
= cpu_to_le16(search_flags
);
4407 name_len
= psrch_inf
->resume_name_len
;
4409 if (name_len
< PATH_MAX
) {
4410 memcpy(pSMB
->ResumeFileName
, psrch_inf
->presume_name
, name_len
);
4411 byte_count
+= name_len
;
4412 /* 14 byte parm len above enough for 2 byte null terminator */
4413 pSMB
->ResumeFileName
[name_len
] = 0;
4414 pSMB
->ResumeFileName
[name_len
+1] = 0;
4417 goto FNext2_err_exit
;
4419 byte_count
= params
+ 1 /* pad */ ;
4420 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4421 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4422 inc_rfc1001_len(pSMB
, byte_count
);
4423 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4425 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4426 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4427 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_fnext
);
4430 psrch_inf
->endOfSearch
= true;
4431 cifs_buf_release(pSMB
);
4432 rc
= 0; /* search probably was closed at end of search*/
4434 cifs_dbg(FYI
, "FindNext returned = %d\n", rc
);
4435 } else { /* decode response */
4436 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4441 /* BB fixme add lock for file (srch_info) struct here */
4442 if (pSMBr
->hdr
.Flags2
& SMBFLG2_UNICODE
)
4443 psrch_inf
->unicode
= true;
4445 psrch_inf
->unicode
= false;
4446 response_data
= (char *) &pSMBr
->hdr
.Protocol
+
4447 le16_to_cpu(pSMBr
->t2
.ParameterOffset
);
4448 parms
= (T2_FNEXT_RSP_PARMS
*)response_data
;
4449 response_data
= (char *)&pSMBr
->hdr
.Protocol
+
4450 le16_to_cpu(pSMBr
->t2
.DataOffset
);
4451 if (psrch_inf
->smallBuf
)
4452 cifs_small_buf_release(
4453 psrch_inf
->ntwrk_buf_start
);
4455 cifs_buf_release(psrch_inf
->ntwrk_buf_start
);
4456 psrch_inf
->srch_entries_start
= response_data
;
4457 psrch_inf
->ntwrk_buf_start
= (char *)pSMB
;
4458 psrch_inf
->smallBuf
= 0;
4459 if (parms
->EndofSearch
)
4460 psrch_inf
->endOfSearch
= true;
4462 psrch_inf
->endOfSearch
= false;
4463 psrch_inf
->entries_in_buffer
=
4464 le16_to_cpu(parms
->SearchCount
);
4465 psrch_inf
->index_of_last_entry
+=
4466 psrch_inf
->entries_in_buffer
;
4467 lnoff
= le16_to_cpu(parms
->LastNameOffset
);
4468 if (CIFSMaxBufSize
< lnoff
) {
4469 cifs_dbg(VFS
, "ignoring corrupt resume name\n");
4470 psrch_inf
->last_entry
= NULL
;
4473 psrch_inf
->last_entry
=
4474 psrch_inf
->srch_entries_start
+ lnoff
;
4476 /* cifs_dbg(FYI, "fnxt2 entries in buf %d index_of_last %d\n",
4477 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4479 /* BB fixme add unlock here */
4484 /* BB On error, should we leave previous search buf (and count and
4485 last entry fields) intact or free the previous one? */
4487 /* Note: On -EAGAIN error only caller can retry on handle based calls
4488 since file handle passed in no longer valid */
4491 cifs_buf_release(pSMB
);
4496 CIFSFindClose(const unsigned int xid
, struct cifs_tcon
*tcon
,
4497 const __u16 searchHandle
)
4500 FINDCLOSE_REQ
*pSMB
= NULL
;
4502 cifs_dbg(FYI
, "In CIFSSMBFindClose\n");
4503 rc
= small_smb_init(SMB_COM_FIND_CLOSE2
, 1, tcon
, (void **)&pSMB
);
4505 /* no sense returning error if session restarted
4506 as file handle has been closed */
4512 pSMB
->FileID
= searchHandle
;
4513 pSMB
->ByteCount
= 0;
4514 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
4516 cifs_dbg(VFS
, "Send error in FindClose = %d\n", rc
);
4518 cifs_stats_inc(&tcon
->stats
.cifs_stats
.num_fclose
);
4520 /* Since session is dead, search handle closed on server already */
4528 CIFSGetSrvInodeNumber(const unsigned int xid
, struct cifs_tcon
*tcon
,
4529 const char *search_name
, __u64
*inode_number
,
4530 const struct nls_table
*nls_codepage
, int remap
)
4533 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
4534 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
4535 int name_len
, bytes_returned
;
4536 __u16 params
, byte_count
;
4538 cifs_dbg(FYI
, "In GetSrvInodeNum for %s\n", search_name
);
4542 GetInodeNumberRetry
:
4543 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4548 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
4550 cifsConvertToUTF16((__le16
*) pSMB
->FileName
,
4551 search_name
, PATH_MAX
, nls_codepage
,
4553 name_len
++; /* trailing null */
4555 } else { /* BB improve the check for buffer overruns BB */
4556 name_len
= strnlen(search_name
, PATH_MAX
);
4557 name_len
++; /* trailing null */
4558 strncpy(pSMB
->FileName
, search_name
, name_len
);
4561 params
= 2 /* level */ + 4 /* rsrvd */ + name_len
/* incl null */ ;
4562 pSMB
->TotalDataCount
= 0;
4563 pSMB
->MaxParameterCount
= cpu_to_le16(2);
4564 /* BB find exact max data count below from sess structure BB */
4565 pSMB
->MaxDataCount
= cpu_to_le16(4000);
4566 pSMB
->MaxSetupCount
= 0;
4570 pSMB
->Reserved2
= 0;
4571 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
4572 struct smb_com_transaction2_qpi_req
, InformationLevel
) - 4);
4573 pSMB
->DataCount
= 0;
4574 pSMB
->DataOffset
= 0;
4575 pSMB
->SetupCount
= 1;
4576 pSMB
->Reserved3
= 0;
4577 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
4578 byte_count
= params
+ 1 /* pad */ ;
4579 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4580 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4581 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO
);
4582 pSMB
->Reserved4
= 0;
4583 inc_rfc1001_len(pSMB
, byte_count
);
4584 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4586 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4587 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4589 cifs_dbg(FYI
, "error %d in QueryInternalInfo\n", rc
);
4591 /* decode response */
4592 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4593 /* BB also check enough total bytes returned */
4594 if (rc
|| get_bcc(&pSMBr
->hdr
) < 2)
4595 /* If rc should we check for EOPNOSUPP and
4596 disable the srvino flag? or in caller? */
4597 rc
= -EIO
; /* bad smb */
4599 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4600 __u16 count
= le16_to_cpu(pSMBr
->t2
.DataCount
);
4601 struct file_internal_info
*pfinfo
;
4602 /* BB Do we need a cast or hash here ? */
4604 cifs_dbg(FYI
, "Illegal size ret in QryIntrnlInf\n");
4606 goto GetInodeNumOut
;
4608 pfinfo
= (struct file_internal_info
*)
4609 (data_offset
+ (char *) &pSMBr
->hdr
.Protocol
);
4610 *inode_number
= le64_to_cpu(pfinfo
->UniqueId
);
4614 cifs_buf_release(pSMB
);
4616 goto GetInodeNumberRetry
;
4620 /* parses DFS refferal V3 structure
4621 * caller is responsible for freeing target_nodes
4624 * on failure - errno
4627 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP
*pSMBr
,
4628 unsigned int *num_of_nodes
,
4629 struct dfs_info3_param
**target_nodes
,
4630 const struct nls_table
*nls_codepage
, int remap
,
4631 const char *searchName
)
4636 struct dfs_referral_level_3
*ref
;
4638 if (pSMBr
->hdr
.Flags2
& SMBFLG2_UNICODE
)
4642 *num_of_nodes
= le16_to_cpu(pSMBr
->NumberOfReferrals
);
4644 if (*num_of_nodes
< 1) {
4645 cifs_dbg(VFS
, "num_referrals: must be at least > 0, but we get num_referrals = %d\n",
4648 goto parse_DFS_referrals_exit
;
4651 ref
= (struct dfs_referral_level_3
*) &(pSMBr
->referrals
);
4652 if (ref
->VersionNumber
!= cpu_to_le16(3)) {
4653 cifs_dbg(VFS
, "Referrals of V%d version are not supported, should be V3\n",
4654 le16_to_cpu(ref
->VersionNumber
));
4656 goto parse_DFS_referrals_exit
;
4659 /* get the upper boundary of the resp buffer */
4660 data_end
= (char *)(&(pSMBr
->PathConsumed
)) +
4661 le16_to_cpu(pSMBr
->t2
.DataCount
);
4663 cifs_dbg(FYI
, "num_referrals: %d dfs flags: 0x%x ...\n",
4664 *num_of_nodes
, le32_to_cpu(pSMBr
->DFSFlags
));
4666 *target_nodes
= kcalloc(*num_of_nodes
, sizeof(struct dfs_info3_param
),
4668 if (*target_nodes
== NULL
) {
4670 goto parse_DFS_referrals_exit
;
4673 /* collect necessary data from referrals */
4674 for (i
= 0; i
< *num_of_nodes
; i
++) {
4677 struct dfs_info3_param
*node
= (*target_nodes
)+i
;
4679 node
->flags
= le32_to_cpu(pSMBr
->DFSFlags
);
4681 __le16
*tmp
= kmalloc(strlen(searchName
)*2 + 2,
4685 goto parse_DFS_referrals_exit
;
4687 cifsConvertToUTF16((__le16
*) tmp
, searchName
,
4688 PATH_MAX
, nls_codepage
, remap
);
4689 node
->path_consumed
= cifs_utf16_bytes(tmp
,
4690 le16_to_cpu(pSMBr
->PathConsumed
),
4694 node
->path_consumed
= le16_to_cpu(pSMBr
->PathConsumed
);
4696 node
->server_type
= le16_to_cpu(ref
->ServerType
);
4697 node
->ref_flag
= le16_to_cpu(ref
->ReferralEntryFlags
);
4700 temp
= (char *)ref
+ le16_to_cpu(ref
->DfsPathOffset
);
4701 max_len
= data_end
- temp
;
4702 node
->path_name
= cifs_strndup_from_utf16(temp
, max_len
,
4703 is_unicode
, nls_codepage
);
4704 if (!node
->path_name
) {
4706 goto parse_DFS_referrals_exit
;
4709 /* copy link target UNC */
4710 temp
= (char *)ref
+ le16_to_cpu(ref
->NetworkAddressOffset
);
4711 max_len
= data_end
- temp
;
4712 node
->node_name
= cifs_strndup_from_utf16(temp
, max_len
,
4713 is_unicode
, nls_codepage
);
4714 if (!node
->node_name
) {
4716 goto parse_DFS_referrals_exit
;
4722 parse_DFS_referrals_exit
:
4724 free_dfs_info_array(*target_nodes
, *num_of_nodes
);
4725 *target_nodes
= NULL
;
4732 CIFSGetDFSRefer(const unsigned int xid
, struct cifs_ses
*ses
,
4733 const char *search_name
, struct dfs_info3_param
**target_nodes
,
4734 unsigned int *num_of_nodes
,
4735 const struct nls_table
*nls_codepage
, int remap
)
4737 /* TRANS2_GET_DFS_REFERRAL */
4738 TRANSACTION2_GET_DFS_REFER_REQ
*pSMB
= NULL
;
4739 TRANSACTION2_GET_DFS_REFER_RSP
*pSMBr
= NULL
;
4743 __u16 params
, byte_count
;
4745 *target_nodes
= NULL
;
4747 cifs_dbg(FYI
, "In GetDFSRefer the path %s\n", search_name
);
4751 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, NULL
, (void **) &pSMB
,
4756 /* server pointer checked in called function,
4757 but should never be null here anyway */
4758 pSMB
->hdr
.Mid
= get_next_mid(ses
->server
);
4759 pSMB
->hdr
.Tid
= ses
->ipc_tid
;
4760 pSMB
->hdr
.Uid
= ses
->Suid
;
4761 if (ses
->capabilities
& CAP_STATUS32
)
4762 pSMB
->hdr
.Flags2
|= SMBFLG2_ERR_STATUS
;
4763 if (ses
->capabilities
& CAP_DFS
)
4764 pSMB
->hdr
.Flags2
|= SMBFLG2_DFS
;
4766 if (ses
->capabilities
& CAP_UNICODE
) {
4767 pSMB
->hdr
.Flags2
|= SMBFLG2_UNICODE
;
4769 cifsConvertToUTF16((__le16
*) pSMB
->RequestFileName
,
4770 search_name
, PATH_MAX
, nls_codepage
,
4772 name_len
++; /* trailing null */
4774 } else { /* BB improve the check for buffer overruns BB */
4775 name_len
= strnlen(search_name
, PATH_MAX
);
4776 name_len
++; /* trailing null */
4777 strncpy(pSMB
->RequestFileName
, search_name
, name_len
);
4780 if (ses
->server
&& ses
->server
->sign
)
4781 pSMB
->hdr
.Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
4783 pSMB
->hdr
.Uid
= ses
->Suid
;
4785 params
= 2 /* level */ + name_len
/*includes null */ ;
4786 pSMB
->TotalDataCount
= 0;
4787 pSMB
->DataCount
= 0;
4788 pSMB
->DataOffset
= 0;
4789 pSMB
->MaxParameterCount
= 0;
4790 /* BB find exact max SMB PDU from sess structure BB */
4791 pSMB
->MaxDataCount
= cpu_to_le16(4000);
4792 pSMB
->MaxSetupCount
= 0;
4796 pSMB
->Reserved2
= 0;
4797 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
4798 struct smb_com_transaction2_get_dfs_refer_req
, MaxReferralLevel
) - 4);
4799 pSMB
->SetupCount
= 1;
4800 pSMB
->Reserved3
= 0;
4801 pSMB
->SubCommand
= cpu_to_le16(TRANS2_GET_DFS_REFERRAL
);
4802 byte_count
= params
+ 3 /* pad */ ;
4803 pSMB
->ParameterCount
= cpu_to_le16(params
);
4804 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
4805 pSMB
->MaxReferralLevel
= cpu_to_le16(3);
4806 inc_rfc1001_len(pSMB
, byte_count
);
4807 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4809 rc
= SendReceive(xid
, ses
, (struct smb_hdr
*) pSMB
,
4810 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4812 cifs_dbg(FYI
, "Send error in GetDFSRefer = %d\n", rc
);
4815 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4817 /* BB Also check if enough total bytes returned? */
4818 if (rc
|| get_bcc(&pSMBr
->hdr
) < 17) {
4819 rc
= -EIO
; /* bad smb */
4823 cifs_dbg(FYI
, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4824 get_bcc(&pSMBr
->hdr
), le16_to_cpu(pSMBr
->t2
.DataOffset
));
4826 /* parse returned result into more usable form */
4827 rc
= parse_DFS_referrals(pSMBr
, num_of_nodes
,
4828 target_nodes
, nls_codepage
, remap
,
4832 cifs_buf_release(pSMB
);
4840 /* Query File System Info such as free space to old servers such as Win 9x */
4842 SMBOldQFSInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
4843 struct kstatfs
*FSData
)
4845 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4846 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
4847 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
4848 FILE_SYSTEM_ALLOC_INFO
*response_data
;
4850 int bytes_returned
= 0;
4851 __u16 params
, byte_count
;
4853 cifs_dbg(FYI
, "OldQFSInfo\n");
4855 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4860 params
= 2; /* level */
4861 pSMB
->TotalDataCount
= 0;
4862 pSMB
->MaxParameterCount
= cpu_to_le16(2);
4863 pSMB
->MaxDataCount
= cpu_to_le16(1000);
4864 pSMB
->MaxSetupCount
= 0;
4868 pSMB
->Reserved2
= 0;
4869 byte_count
= params
+ 1 /* pad */ ;
4870 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4871 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4872 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
4873 struct smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
4874 pSMB
->DataCount
= 0;
4875 pSMB
->DataOffset
= 0;
4876 pSMB
->SetupCount
= 1;
4877 pSMB
->Reserved3
= 0;
4878 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
4879 pSMB
->InformationLevel
= cpu_to_le16(SMB_INFO_ALLOCATION
);
4880 inc_rfc1001_len(pSMB
, byte_count
);
4881 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4883 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4884 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4886 cifs_dbg(FYI
, "Send error in QFSInfo = %d\n", rc
);
4887 } else { /* decode response */
4888 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4890 if (rc
|| get_bcc(&pSMBr
->hdr
) < 18)
4891 rc
= -EIO
; /* bad smb */
4893 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4894 cifs_dbg(FYI
, "qfsinf resp BCC: %d Offset %d\n",
4895 get_bcc(&pSMBr
->hdr
), data_offset
);
4897 response_data
= (FILE_SYSTEM_ALLOC_INFO
*)
4898 (((char *) &pSMBr
->hdr
.Protocol
) + data_offset
);
4900 le16_to_cpu(response_data
->BytesPerSector
) *
4901 le32_to_cpu(response_data
->
4902 SectorsPerAllocationUnit
);
4904 le32_to_cpu(response_data
->TotalAllocationUnits
);
4905 FSData
->f_bfree
= FSData
->f_bavail
=
4906 le32_to_cpu(response_data
->FreeAllocationUnits
);
4907 cifs_dbg(FYI
, "Blocks: %lld Free: %lld Block size %ld\n",
4908 (unsigned long long)FSData
->f_blocks
,
4909 (unsigned long long)FSData
->f_bfree
,
4913 cifs_buf_release(pSMB
);
4916 goto oldQFSInfoRetry
;
4922 CIFSSMBQFSInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
4923 struct kstatfs
*FSData
)
4925 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4926 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
4927 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
4928 FILE_SYSTEM_INFO
*response_data
;
4930 int bytes_returned
= 0;
4931 __u16 params
, byte_count
;
4933 cifs_dbg(FYI
, "In QFSInfo\n");
4935 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
4940 params
= 2; /* level */
4941 pSMB
->TotalDataCount
= 0;
4942 pSMB
->MaxParameterCount
= cpu_to_le16(2);
4943 pSMB
->MaxDataCount
= cpu_to_le16(1000);
4944 pSMB
->MaxSetupCount
= 0;
4948 pSMB
->Reserved2
= 0;
4949 byte_count
= params
+ 1 /* pad */ ;
4950 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
4951 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
4952 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
4953 struct smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
4954 pSMB
->DataCount
= 0;
4955 pSMB
->DataOffset
= 0;
4956 pSMB
->SetupCount
= 1;
4957 pSMB
->Reserved3
= 0;
4958 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
4959 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FS_SIZE_INFO
);
4960 inc_rfc1001_len(pSMB
, byte_count
);
4961 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
4963 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
4964 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
4966 cifs_dbg(FYI
, "Send error in QFSInfo = %d\n", rc
);
4967 } else { /* decode response */
4968 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
4970 if (rc
|| get_bcc(&pSMBr
->hdr
) < 24)
4971 rc
= -EIO
; /* bad smb */
4973 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
4977 *) (((char *) &pSMBr
->hdr
.Protocol
) +
4980 le32_to_cpu(response_data
->BytesPerSector
) *
4981 le32_to_cpu(response_data
->
4982 SectorsPerAllocationUnit
);
4984 le64_to_cpu(response_data
->TotalAllocationUnits
);
4985 FSData
->f_bfree
= FSData
->f_bavail
=
4986 le64_to_cpu(response_data
->FreeAllocationUnits
);
4987 cifs_dbg(FYI
, "Blocks: %lld Free: %lld Block size %ld\n",
4988 (unsigned long long)FSData
->f_blocks
,
4989 (unsigned long long)FSData
->f_bfree
,
4993 cifs_buf_release(pSMB
);
5002 CIFSSMBQFSAttributeInfo(const unsigned int xid
, struct cifs_tcon
*tcon
)
5004 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5005 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
5006 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
5007 FILE_SYSTEM_ATTRIBUTE_INFO
*response_data
;
5009 int bytes_returned
= 0;
5010 __u16 params
, byte_count
;
5012 cifs_dbg(FYI
, "In QFSAttributeInfo\n");
5014 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5019 params
= 2; /* level */
5020 pSMB
->TotalDataCount
= 0;
5021 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5022 /* BB find exact max SMB PDU from sess structure BB */
5023 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5024 pSMB
->MaxSetupCount
= 0;
5028 pSMB
->Reserved2
= 0;
5029 byte_count
= params
+ 1 /* pad */ ;
5030 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
5031 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
5032 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
5033 struct smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
5034 pSMB
->DataCount
= 0;
5035 pSMB
->DataOffset
= 0;
5036 pSMB
->SetupCount
= 1;
5037 pSMB
->Reserved3
= 0;
5038 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
5039 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO
);
5040 inc_rfc1001_len(pSMB
, byte_count
);
5041 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5043 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5044 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5046 cifs_dbg(VFS
, "Send error in QFSAttributeInfo = %d\n", rc
);
5047 } else { /* decode response */
5048 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
5050 if (rc
|| get_bcc(&pSMBr
->hdr
) < 13) {
5051 /* BB also check if enough bytes returned */
5052 rc
= -EIO
; /* bad smb */
5054 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
5056 (FILE_SYSTEM_ATTRIBUTE_INFO
5057 *) (((char *) &pSMBr
->hdr
.Protocol
) +
5059 memcpy(&tcon
->fsAttrInfo
, response_data
,
5060 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO
));
5063 cifs_buf_release(pSMB
);
5066 goto QFSAttributeRetry
;
5072 CIFSSMBQFSDeviceInfo(const unsigned int xid
, struct cifs_tcon
*tcon
)
5074 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5075 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
5076 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
5077 FILE_SYSTEM_DEVICE_INFO
*response_data
;
5079 int bytes_returned
= 0;
5080 __u16 params
, byte_count
;
5082 cifs_dbg(FYI
, "In QFSDeviceInfo\n");
5084 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5089 params
= 2; /* level */
5090 pSMB
->TotalDataCount
= 0;
5091 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5092 /* BB find exact max SMB PDU from sess structure BB */
5093 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5094 pSMB
->MaxSetupCount
= 0;
5098 pSMB
->Reserved2
= 0;
5099 byte_count
= params
+ 1 /* pad */ ;
5100 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
5101 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
5102 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
5103 struct smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
5105 pSMB
->DataCount
= 0;
5106 pSMB
->DataOffset
= 0;
5107 pSMB
->SetupCount
= 1;
5108 pSMB
->Reserved3
= 0;
5109 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
5110 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO
);
5111 inc_rfc1001_len(pSMB
, byte_count
);
5112 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5114 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5115 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5117 cifs_dbg(FYI
, "Send error in QFSDeviceInfo = %d\n", rc
);
5118 } else { /* decode response */
5119 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
5121 if (rc
|| get_bcc(&pSMBr
->hdr
) <
5122 sizeof(FILE_SYSTEM_DEVICE_INFO
))
5123 rc
= -EIO
; /* bad smb */
5125 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
5127 (FILE_SYSTEM_DEVICE_INFO
*)
5128 (((char *) &pSMBr
->hdr
.Protocol
) +
5130 memcpy(&tcon
->fsDevInfo
, response_data
,
5131 sizeof(FILE_SYSTEM_DEVICE_INFO
));
5134 cifs_buf_release(pSMB
);
5137 goto QFSDeviceRetry
;
5143 CIFSSMBQFSUnixInfo(const unsigned int xid
, struct cifs_tcon
*tcon
)
5145 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5146 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
5147 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
5148 FILE_SYSTEM_UNIX_INFO
*response_data
;
5150 int bytes_returned
= 0;
5151 __u16 params
, byte_count
;
5153 cifs_dbg(FYI
, "In QFSUnixInfo\n");
5155 rc
= smb_init_no_reconnect(SMB_COM_TRANSACTION2
, 15, tcon
,
5156 (void **) &pSMB
, (void **) &pSMBr
);
5160 params
= 2; /* level */
5161 pSMB
->TotalDataCount
= 0;
5162 pSMB
->DataCount
= 0;
5163 pSMB
->DataOffset
= 0;
5164 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5165 /* BB find exact max SMB PDU from sess structure BB */
5166 pSMB
->MaxDataCount
= cpu_to_le16(100);
5167 pSMB
->MaxSetupCount
= 0;
5171 pSMB
->Reserved2
= 0;
5172 byte_count
= params
+ 1 /* pad */ ;
5173 pSMB
->ParameterCount
= cpu_to_le16(params
);
5174 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5175 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(struct
5176 smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
5177 pSMB
->SetupCount
= 1;
5178 pSMB
->Reserved3
= 0;
5179 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
5180 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO
);
5181 inc_rfc1001_len(pSMB
, byte_count
);
5182 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5184 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5185 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5187 cifs_dbg(VFS
, "Send error in QFSUnixInfo = %d\n", rc
);
5188 } else { /* decode response */
5189 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
5191 if (rc
|| get_bcc(&pSMBr
->hdr
) < 13) {
5192 rc
= -EIO
; /* bad smb */
5194 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
5196 (FILE_SYSTEM_UNIX_INFO
5197 *) (((char *) &pSMBr
->hdr
.Protocol
) +
5199 memcpy(&tcon
->fsUnixInfo
, response_data
,
5200 sizeof(FILE_SYSTEM_UNIX_INFO
));
5203 cifs_buf_release(pSMB
);
5213 CIFSSMBSetFSUnixInfo(const unsigned int xid
, struct cifs_tcon
*tcon
, __u64 cap
)
5215 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5216 TRANSACTION2_SETFSI_REQ
*pSMB
= NULL
;
5217 TRANSACTION2_SETFSI_RSP
*pSMBr
= NULL
;
5219 int bytes_returned
= 0;
5220 __u16 params
, param_offset
, offset
, byte_count
;
5222 cifs_dbg(FYI
, "In SETFSUnixInfo\n");
5224 /* BB switch to small buf init to save memory */
5225 rc
= smb_init_no_reconnect(SMB_COM_TRANSACTION2
, 15, tcon
,
5226 (void **) &pSMB
, (void **) &pSMBr
);
5230 params
= 4; /* 2 bytes zero followed by info level. */
5231 pSMB
->MaxSetupCount
= 0;
5235 pSMB
->Reserved2
= 0;
5236 param_offset
= offsetof(struct smb_com_transaction2_setfsi_req
, FileNum
)
5238 offset
= param_offset
+ params
;
5240 pSMB
->MaxParameterCount
= cpu_to_le16(4);
5241 /* BB find exact max SMB PDU from sess structure BB */
5242 pSMB
->MaxDataCount
= cpu_to_le16(100);
5243 pSMB
->SetupCount
= 1;
5244 pSMB
->Reserved3
= 0;
5245 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FS_INFORMATION
);
5246 byte_count
= 1 /* pad */ + params
+ 12;
5248 pSMB
->DataCount
= cpu_to_le16(12);
5249 pSMB
->ParameterCount
= cpu_to_le16(params
);
5250 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5251 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5252 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5253 pSMB
->DataOffset
= cpu_to_le16(offset
);
5257 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_CIFS_UNIX_INFO
);
5260 pSMB
->ClientUnixMajor
= cpu_to_le16(CIFS_UNIX_MAJOR_VERSION
);
5261 pSMB
->ClientUnixMinor
= cpu_to_le16(CIFS_UNIX_MINOR_VERSION
);
5262 pSMB
->ClientUnixCap
= cpu_to_le64(cap
);
5264 inc_rfc1001_len(pSMB
, byte_count
);
5265 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5267 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5268 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5270 cifs_dbg(VFS
, "Send error in SETFSUnixInfo = %d\n", rc
);
5271 } else { /* decode response */
5272 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
5274 rc
= -EIO
; /* bad smb */
5276 cifs_buf_release(pSMB
);
5279 goto SETFSUnixRetry
;
5287 CIFSSMBQFSPosixInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
5288 struct kstatfs
*FSData
)
5290 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5291 TRANSACTION2_QFSI_REQ
*pSMB
= NULL
;
5292 TRANSACTION2_QFSI_RSP
*pSMBr
= NULL
;
5293 FILE_SYSTEM_POSIX_INFO
*response_data
;
5295 int bytes_returned
= 0;
5296 __u16 params
, byte_count
;
5298 cifs_dbg(FYI
, "In QFSPosixInfo\n");
5300 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5305 params
= 2; /* level */
5306 pSMB
->TotalDataCount
= 0;
5307 pSMB
->DataCount
= 0;
5308 pSMB
->DataOffset
= 0;
5309 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5310 /* BB find exact max SMB PDU from sess structure BB */
5311 pSMB
->MaxDataCount
= cpu_to_le16(100);
5312 pSMB
->MaxSetupCount
= 0;
5316 pSMB
->Reserved2
= 0;
5317 byte_count
= params
+ 1 /* pad */ ;
5318 pSMB
->ParameterCount
= cpu_to_le16(params
);
5319 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5320 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(struct
5321 smb_com_transaction2_qfsi_req
, InformationLevel
) - 4);
5322 pSMB
->SetupCount
= 1;
5323 pSMB
->Reserved3
= 0;
5324 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_FS_INFORMATION
);
5325 pSMB
->InformationLevel
= cpu_to_le16(SMB_QUERY_POSIX_FS_INFO
);
5326 inc_rfc1001_len(pSMB
, byte_count
);
5327 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5329 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5330 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5332 cifs_dbg(FYI
, "Send error in QFSUnixInfo = %d\n", rc
);
5333 } else { /* decode response */
5334 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
5336 if (rc
|| get_bcc(&pSMBr
->hdr
) < 13) {
5337 rc
= -EIO
; /* bad smb */
5339 __u16 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
5341 (FILE_SYSTEM_POSIX_INFO
5342 *) (((char *) &pSMBr
->hdr
.Protocol
) +
5345 le32_to_cpu(response_data
->BlockSize
);
5347 le64_to_cpu(response_data
->TotalBlocks
);
5349 le64_to_cpu(response_data
->BlocksAvail
);
5350 if (response_data
->UserBlocksAvail
== cpu_to_le64(-1)) {
5351 FSData
->f_bavail
= FSData
->f_bfree
;
5354 le64_to_cpu(response_data
->UserBlocksAvail
);
5356 if (response_data
->TotalFileNodes
!= cpu_to_le64(-1))
5358 le64_to_cpu(response_data
->TotalFileNodes
);
5359 if (response_data
->FreeFileNodes
!= cpu_to_le64(-1))
5361 le64_to_cpu(response_data
->FreeFileNodes
);
5364 cifs_buf_release(pSMB
);
5374 * We can not use write of zero bytes trick to set file size due to need for
5375 * large file support. Also note that this SetPathInfo is preferred to
5376 * SetFileInfo based method in next routine which is only needed to work around
5377 * a sharing violation bugin Samba which this routine can run into.
5380 CIFSSMBSetEOF(const unsigned int xid
, struct cifs_tcon
*tcon
,
5381 const char *file_name
, __u64 size
, struct cifs_sb_info
*cifs_sb
,
5382 bool set_allocation
)
5384 struct smb_com_transaction2_spi_req
*pSMB
= NULL
;
5385 struct smb_com_transaction2_spi_rsp
*pSMBr
= NULL
;
5386 struct file_end_of_file_info
*parm_data
;
5389 int bytes_returned
= 0;
5390 int remap
= cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
;
5392 __u16 params
, byte_count
, data_count
, param_offset
, offset
;
5394 cifs_dbg(FYI
, "In SetEOF\n");
5396 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5401 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
5403 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, file_name
,
5404 PATH_MAX
, cifs_sb
->local_nls
, remap
);
5405 name_len
++; /* trailing null */
5407 } else { /* BB improve the check for buffer overruns BB */
5408 name_len
= strnlen(file_name
, PATH_MAX
);
5409 name_len
++; /* trailing null */
5410 strncpy(pSMB
->FileName
, file_name
, name_len
);
5412 params
= 6 + name_len
;
5413 data_count
= sizeof(struct file_end_of_file_info
);
5414 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5415 pSMB
->MaxDataCount
= cpu_to_le16(4100);
5416 pSMB
->MaxSetupCount
= 0;
5420 pSMB
->Reserved2
= 0;
5421 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
5422 InformationLevel
) - 4;
5423 offset
= param_offset
+ params
;
5424 if (set_allocation
) {
5425 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5426 pSMB
->InformationLevel
=
5427 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2
);
5429 pSMB
->InformationLevel
=
5430 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO
);
5431 } else /* Set File Size */ {
5432 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5433 pSMB
->InformationLevel
=
5434 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2
);
5436 pSMB
->InformationLevel
=
5437 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO
);
5441 (struct file_end_of_file_info
*) (((char *) &pSMB
->hdr
.Protocol
) +
5443 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5444 pSMB
->DataOffset
= cpu_to_le16(offset
);
5445 pSMB
->SetupCount
= 1;
5446 pSMB
->Reserved3
= 0;
5447 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
5448 byte_count
= 3 /* pad */ + params
+ data_count
;
5449 pSMB
->DataCount
= cpu_to_le16(data_count
);
5450 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5451 pSMB
->ParameterCount
= cpu_to_le16(params
);
5452 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5453 pSMB
->Reserved4
= 0;
5454 inc_rfc1001_len(pSMB
, byte_count
);
5455 parm_data
->FileSize
= cpu_to_le64(size
);
5456 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5457 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5458 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5460 cifs_dbg(FYI
, "SetPathInfo (file size) returned %d\n", rc
);
5462 cifs_buf_release(pSMB
);
5471 CIFSSMBSetFileSize(const unsigned int xid
, struct cifs_tcon
*tcon
,
5472 struct cifsFileInfo
*cfile
, __u64 size
, bool set_allocation
)
5474 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
5475 struct file_end_of_file_info
*parm_data
;
5477 __u16 params
, param_offset
, offset
, byte_count
, count
;
5479 cifs_dbg(FYI
, "SetFileSize (via SetFileInfo) %lld\n",
5481 rc
= small_smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
);
5486 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)cfile
->pid
);
5487 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(cfile
->pid
>> 16));
5490 pSMB
->MaxSetupCount
= 0;
5494 pSMB
->Reserved2
= 0;
5495 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
5496 offset
= param_offset
+ params
;
5498 count
= sizeof(struct file_end_of_file_info
);
5499 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5500 /* BB find exact max SMB PDU from sess structure BB */
5501 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5502 pSMB
->SetupCount
= 1;
5503 pSMB
->Reserved3
= 0;
5504 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
5505 byte_count
= 3 /* pad */ + params
+ count
;
5506 pSMB
->DataCount
= cpu_to_le16(count
);
5507 pSMB
->ParameterCount
= cpu_to_le16(params
);
5508 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5509 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5510 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5512 (struct file_end_of_file_info
*) (((char *) &pSMB
->hdr
.Protocol
)
5514 pSMB
->DataOffset
= cpu_to_le16(offset
);
5515 parm_data
->FileSize
= cpu_to_le64(size
);
5516 pSMB
->Fid
= cfile
->fid
.netfid
;
5517 if (set_allocation
) {
5518 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5519 pSMB
->InformationLevel
=
5520 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2
);
5522 pSMB
->InformationLevel
=
5523 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO
);
5524 } else /* Set File Size */ {
5525 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5526 pSMB
->InformationLevel
=
5527 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2
);
5529 pSMB
->InformationLevel
=
5530 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO
);
5532 pSMB
->Reserved4
= 0;
5533 inc_rfc1001_len(pSMB
, byte_count
);
5534 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5535 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
5537 cifs_dbg(FYI
, "Send error in SetFileInfo (SetFileSize) = %d\n",
5541 /* Note: On -EAGAIN error only caller can retry on handle based calls
5542 since file handle passed in no longer valid */
5547 /* Some legacy servers such as NT4 require that the file times be set on
5548 an open handle, rather than by pathname - this is awkward due to
5549 potential access conflicts on the open, but it is unavoidable for these
5550 old servers since the only other choice is to go from 100 nanosecond DCE
5551 time and resort to the original setpathinfo level which takes the ancient
5552 DOS time format with 2 second granularity */
5554 CIFSSMBSetFileInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
5555 const FILE_BASIC_INFO
*data
, __u16 fid
, __u32 pid_of_opener
)
5557 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
5560 __u16 params
, param_offset
, offset
, byte_count
, count
;
5562 cifs_dbg(FYI
, "Set Times (via SetFileInfo)\n");
5563 rc
= small_smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
);
5568 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid_of_opener
);
5569 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid_of_opener
>> 16));
5572 pSMB
->MaxSetupCount
= 0;
5576 pSMB
->Reserved2
= 0;
5577 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
5578 offset
= param_offset
+ params
;
5580 data_offset
= (char *)pSMB
+
5581 offsetof(struct smb_hdr
, Protocol
) + offset
;
5583 count
= sizeof(FILE_BASIC_INFO
);
5584 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5585 /* BB find max SMB PDU from sess */
5586 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5587 pSMB
->SetupCount
= 1;
5588 pSMB
->Reserved3
= 0;
5589 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
5590 byte_count
= 3 /* pad */ + params
+ count
;
5591 pSMB
->DataCount
= cpu_to_le16(count
);
5592 pSMB
->ParameterCount
= cpu_to_le16(params
);
5593 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5594 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5595 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5596 pSMB
->DataOffset
= cpu_to_le16(offset
);
5598 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5599 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_BASIC_INFO2
);
5601 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_BASIC_INFO
);
5602 pSMB
->Reserved4
= 0;
5603 inc_rfc1001_len(pSMB
, byte_count
);
5604 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5605 memcpy(data_offset
, data
, sizeof(FILE_BASIC_INFO
));
5606 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
5608 cifs_dbg(FYI
, "Send error in Set Time (SetFileInfo) = %d\n",
5611 /* Note: On -EAGAIN error only caller can retry on handle based calls
5612 since file handle passed in no longer valid */
5618 CIFSSMBSetFileDisposition(const unsigned int xid
, struct cifs_tcon
*tcon
,
5619 bool delete_file
, __u16 fid
, __u32 pid_of_opener
)
5621 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
5624 __u16 params
, param_offset
, offset
, byte_count
, count
;
5626 cifs_dbg(FYI
, "Set File Disposition (via SetFileInfo)\n");
5627 rc
= small_smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
);
5632 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid_of_opener
);
5633 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid_of_opener
>> 16));
5636 pSMB
->MaxSetupCount
= 0;
5640 pSMB
->Reserved2
= 0;
5641 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
5642 offset
= param_offset
+ params
;
5644 data_offset
= (char *) (&pSMB
->hdr
.Protocol
) + offset
;
5647 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5648 /* BB find max SMB PDU from sess */
5649 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5650 pSMB
->SetupCount
= 1;
5651 pSMB
->Reserved3
= 0;
5652 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
5653 byte_count
= 3 /* pad */ + params
+ count
;
5654 pSMB
->DataCount
= cpu_to_le16(count
);
5655 pSMB
->ParameterCount
= cpu_to_le16(params
);
5656 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5657 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5658 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5659 pSMB
->DataOffset
= cpu_to_le16(offset
);
5661 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO
);
5662 pSMB
->Reserved4
= 0;
5663 inc_rfc1001_len(pSMB
, byte_count
);
5664 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5665 *data_offset
= delete_file
? 1 : 0;
5666 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
5668 cifs_dbg(FYI
, "Send error in SetFileDisposition = %d\n", rc
);
5674 CIFSSMBSetPathInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
5675 const char *fileName
, const FILE_BASIC_INFO
*data
,
5676 const struct nls_table
*nls_codepage
, int remap
)
5678 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
5679 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
5682 int bytes_returned
= 0;
5684 __u16 params
, param_offset
, offset
, byte_count
, count
;
5686 cifs_dbg(FYI
, "In SetTimes\n");
5689 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5694 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
5696 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, fileName
,
5697 PATH_MAX
, nls_codepage
, remap
);
5698 name_len
++; /* trailing null */
5700 } else { /* BB improve the check for buffer overruns BB */
5701 name_len
= strnlen(fileName
, PATH_MAX
);
5702 name_len
++; /* trailing null */
5703 strncpy(pSMB
->FileName
, fileName
, name_len
);
5706 params
= 6 + name_len
;
5707 count
= sizeof(FILE_BASIC_INFO
);
5708 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5709 /* BB find max SMB PDU from sess structure BB */
5710 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5711 pSMB
->MaxSetupCount
= 0;
5715 pSMB
->Reserved2
= 0;
5716 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
5717 InformationLevel
) - 4;
5718 offset
= param_offset
+ params
;
5719 data_offset
= (char *) (&pSMB
->hdr
.Protocol
) + offset
;
5720 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5721 pSMB
->DataOffset
= cpu_to_le16(offset
);
5722 pSMB
->SetupCount
= 1;
5723 pSMB
->Reserved3
= 0;
5724 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
5725 byte_count
= 3 /* pad */ + params
+ count
;
5727 pSMB
->DataCount
= cpu_to_le16(count
);
5728 pSMB
->ParameterCount
= cpu_to_le16(params
);
5729 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5730 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5731 if (tcon
->ses
->capabilities
& CAP_INFOLEVEL_PASSTHRU
)
5732 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_BASIC_INFO2
);
5734 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_BASIC_INFO
);
5735 pSMB
->Reserved4
= 0;
5736 inc_rfc1001_len(pSMB
, byte_count
);
5737 memcpy(data_offset
, data
, sizeof(FILE_BASIC_INFO
));
5738 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5739 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5740 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5742 cifs_dbg(FYI
, "SetPathInfo (times) returned %d\n", rc
);
5744 cifs_buf_release(pSMB
);
5752 /* Can not be used to set time stamps yet (due to old DOS time format) */
5753 /* Can be used to set attributes */
5754 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5755 handling it anyway and NT4 was what we thought it would be needed for
5756 Do not delete it until we prove whether needed for Win9x though */
5758 CIFSSMBSetAttrLegacy(unsigned int xid
, struct cifs_tcon
*tcon
, char *fileName
,
5759 __u16 dos_attrs
, const struct nls_table
*nls_codepage
)
5761 SETATTR_REQ
*pSMB
= NULL
;
5762 SETATTR_RSP
*pSMBr
= NULL
;
5767 cifs_dbg(FYI
, "In SetAttrLegacy\n");
5770 rc
= smb_init(SMB_COM_SETATTR
, 8, tcon
, (void **) &pSMB
,
5775 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
5777 ConvertToUTF16((__le16
*) pSMB
->fileName
, fileName
,
5778 PATH_MAX
, nls_codepage
);
5779 name_len
++; /* trailing null */
5781 } else { /* BB improve the check for buffer overruns BB */
5782 name_len
= strnlen(fileName
, PATH_MAX
);
5783 name_len
++; /* trailing null */
5784 strncpy(pSMB
->fileName
, fileName
, name_len
);
5786 pSMB
->attr
= cpu_to_le16(dos_attrs
);
5787 pSMB
->BufferFormat
= 0x04;
5788 inc_rfc1001_len(pSMB
, name_len
+ 1);
5789 pSMB
->ByteCount
= cpu_to_le16(name_len
+ 1);
5790 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5791 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5793 cifs_dbg(FYI
, "Error in LegacySetAttr = %d\n", rc
);
5795 cifs_buf_release(pSMB
);
5798 goto SetAttrLgcyRetry
;
5802 #endif /* temporarily unneeded SetAttr legacy function */
5805 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO
*data_offset
,
5806 const struct cifs_unix_set_info_args
*args
)
5808 u64 uid
= NO_CHANGE_64
, gid
= NO_CHANGE_64
;
5809 u64 mode
= args
->mode
;
5811 if (uid_valid(args
->uid
))
5812 uid
= from_kuid(&init_user_ns
, args
->uid
);
5813 if (gid_valid(args
->gid
))
5814 gid
= from_kgid(&init_user_ns
, args
->gid
);
5817 * Samba server ignores set of file size to zero due to bugs in some
5818 * older clients, but we should be precise - we use SetFileSize to
5819 * set file size and do not want to truncate file size to zero
5820 * accidentally as happened on one Samba server beta by putting
5821 * zero instead of -1 here
5823 data_offset
->EndOfFile
= cpu_to_le64(NO_CHANGE_64
);
5824 data_offset
->NumOfBytes
= cpu_to_le64(NO_CHANGE_64
);
5825 data_offset
->LastStatusChange
= cpu_to_le64(args
->ctime
);
5826 data_offset
->LastAccessTime
= cpu_to_le64(args
->atime
);
5827 data_offset
->LastModificationTime
= cpu_to_le64(args
->mtime
);
5828 data_offset
->Uid
= cpu_to_le64(uid
);
5829 data_offset
->Gid
= cpu_to_le64(gid
);
5830 /* better to leave device as zero when it is */
5831 data_offset
->DevMajor
= cpu_to_le64(MAJOR(args
->device
));
5832 data_offset
->DevMinor
= cpu_to_le64(MINOR(args
->device
));
5833 data_offset
->Permissions
= cpu_to_le64(mode
);
5836 data_offset
->Type
= cpu_to_le32(UNIX_FILE
);
5837 else if (S_ISDIR(mode
))
5838 data_offset
->Type
= cpu_to_le32(UNIX_DIR
);
5839 else if (S_ISLNK(mode
))
5840 data_offset
->Type
= cpu_to_le32(UNIX_SYMLINK
);
5841 else if (S_ISCHR(mode
))
5842 data_offset
->Type
= cpu_to_le32(UNIX_CHARDEV
);
5843 else if (S_ISBLK(mode
))
5844 data_offset
->Type
= cpu_to_le32(UNIX_BLOCKDEV
);
5845 else if (S_ISFIFO(mode
))
5846 data_offset
->Type
= cpu_to_le32(UNIX_FIFO
);
5847 else if (S_ISSOCK(mode
))
5848 data_offset
->Type
= cpu_to_le32(UNIX_SOCKET
);
5852 CIFSSMBUnixSetFileInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
5853 const struct cifs_unix_set_info_args
*args
,
5854 u16 fid
, u32 pid_of_opener
)
5856 struct smb_com_transaction2_sfi_req
*pSMB
= NULL
;
5859 u16 params
, param_offset
, offset
, byte_count
, count
;
5861 cifs_dbg(FYI
, "Set Unix Info (via SetFileInfo)\n");
5862 rc
= small_smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
);
5867 pSMB
->hdr
.Pid
= cpu_to_le16((__u16
)pid_of_opener
);
5868 pSMB
->hdr
.PidHigh
= cpu_to_le16((__u16
)(pid_of_opener
>> 16));
5871 pSMB
->MaxSetupCount
= 0;
5875 pSMB
->Reserved2
= 0;
5876 param_offset
= offsetof(struct smb_com_transaction2_sfi_req
, Fid
) - 4;
5877 offset
= param_offset
+ params
;
5879 data_offset
= (char *)pSMB
+
5880 offsetof(struct smb_hdr
, Protocol
) + offset
;
5882 count
= sizeof(FILE_UNIX_BASIC_INFO
);
5884 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5885 /* BB find max SMB PDU from sess */
5886 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5887 pSMB
->SetupCount
= 1;
5888 pSMB
->Reserved3
= 0;
5889 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_FILE_INFORMATION
);
5890 byte_count
= 3 /* pad */ + params
+ count
;
5891 pSMB
->DataCount
= cpu_to_le16(count
);
5892 pSMB
->ParameterCount
= cpu_to_le16(params
);
5893 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5894 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5895 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5896 pSMB
->DataOffset
= cpu_to_le16(offset
);
5898 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_UNIX_BASIC
);
5899 pSMB
->Reserved4
= 0;
5900 inc_rfc1001_len(pSMB
, byte_count
);
5901 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5903 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO
*)data_offset
, args
);
5905 rc
= SendReceiveNoRsp(xid
, tcon
->ses
, (char *) pSMB
, 0);
5907 cifs_dbg(FYI
, "Send error in Set Time (SetFileInfo) = %d\n",
5910 /* Note: On -EAGAIN error only caller can retry on handle based calls
5911 since file handle passed in no longer valid */
5917 CIFSSMBUnixSetPathInfo(const unsigned int xid
, struct cifs_tcon
*tcon
,
5918 const char *file_name
,
5919 const struct cifs_unix_set_info_args
*args
,
5920 const struct nls_table
*nls_codepage
, int remap
)
5922 TRANSACTION2_SPI_REQ
*pSMB
= NULL
;
5923 TRANSACTION2_SPI_RSP
*pSMBr
= NULL
;
5926 int bytes_returned
= 0;
5927 FILE_UNIX_BASIC_INFO
*data_offset
;
5928 __u16 params
, param_offset
, offset
, count
, byte_count
;
5930 cifs_dbg(FYI
, "In SetUID/GID/Mode\n");
5932 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
5937 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
5939 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, file_name
,
5940 PATH_MAX
, nls_codepage
, remap
);
5941 name_len
++; /* trailing null */
5943 } else { /* BB improve the check for buffer overruns BB */
5944 name_len
= strnlen(file_name
, PATH_MAX
);
5945 name_len
++; /* trailing null */
5946 strncpy(pSMB
->FileName
, file_name
, name_len
);
5949 params
= 6 + name_len
;
5950 count
= sizeof(FILE_UNIX_BASIC_INFO
);
5951 pSMB
->MaxParameterCount
= cpu_to_le16(2);
5952 /* BB find max SMB PDU from sess structure BB */
5953 pSMB
->MaxDataCount
= cpu_to_le16(1000);
5954 pSMB
->MaxSetupCount
= 0;
5958 pSMB
->Reserved2
= 0;
5959 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
5960 InformationLevel
) - 4;
5961 offset
= param_offset
+ params
;
5963 (FILE_UNIX_BASIC_INFO
*) ((char *) &pSMB
->hdr
.Protocol
+
5965 memset(data_offset
, 0, count
);
5966 pSMB
->DataOffset
= cpu_to_le16(offset
);
5967 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
5968 pSMB
->SetupCount
= 1;
5969 pSMB
->Reserved3
= 0;
5970 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
5971 byte_count
= 3 /* pad */ + params
+ count
;
5972 pSMB
->ParameterCount
= cpu_to_le16(params
);
5973 pSMB
->DataCount
= cpu_to_le16(count
);
5974 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
5975 pSMB
->TotalDataCount
= pSMB
->DataCount
;
5976 pSMB
->InformationLevel
= cpu_to_le16(SMB_SET_FILE_UNIX_BASIC
);
5977 pSMB
->Reserved4
= 0;
5978 inc_rfc1001_len(pSMB
, byte_count
);
5980 cifs_fill_unix_set_info(data_offset
, args
);
5982 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
5983 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
5984 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
5986 cifs_dbg(FYI
, "SetPathInfo (perms) returned %d\n", rc
);
5988 cifs_buf_release(pSMB
);
5994 #ifdef CONFIG_CIFS_XATTR
5996 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
5997 * function used by listxattr and getxattr type calls. When ea_name is set,
5998 * it looks for that attribute name and stuffs that value into the EAData
5999 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6000 * buffer. In both cases, the return value is either the length of the
6001 * resulting data or a negative error code. If EAData is a NULL pointer then
6002 * the data isn't copied to it, but the length is returned.
6005 CIFSSMBQAllEAs(const unsigned int xid
, struct cifs_tcon
*tcon
,
6006 const unsigned char *searchName
, const unsigned char *ea_name
,
6007 char *EAData
, size_t buf_size
,
6008 const struct nls_table
*nls_codepage
, int remap
)
6010 /* BB assumes one setup word */
6011 TRANSACTION2_QPI_REQ
*pSMB
= NULL
;
6012 TRANSACTION2_QPI_RSP
*pSMBr
= NULL
;
6016 struct fealist
*ea_response_data
;
6017 struct fea
*temp_fea
;
6020 __u16 params
, byte_count
, data_offset
;
6021 unsigned int ea_name_len
= ea_name
? strlen(ea_name
) : 0;
6023 cifs_dbg(FYI
, "In Query All EAs path %s\n", searchName
);
6025 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
6030 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
6032 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, searchName
,
6033 PATH_MAX
, nls_codepage
, remap
);
6034 list_len
++; /* trailing null */
6036 } else { /* BB improve the check for buffer overruns BB */
6037 list_len
= strnlen(searchName
, PATH_MAX
);
6038 list_len
++; /* trailing null */
6039 strncpy(pSMB
->FileName
, searchName
, list_len
);
6042 params
= 2 /* level */ + 4 /* reserved */ + list_len
/* includes NUL */;
6043 pSMB
->TotalDataCount
= 0;
6044 pSMB
->MaxParameterCount
= cpu_to_le16(2);
6045 /* BB find exact max SMB PDU from sess structure BB */
6046 pSMB
->MaxDataCount
= cpu_to_le16(CIFSMaxBufSize
);
6047 pSMB
->MaxSetupCount
= 0;
6051 pSMB
->Reserved2
= 0;
6052 pSMB
->ParameterOffset
= cpu_to_le16(offsetof(
6053 struct smb_com_transaction2_qpi_req
, InformationLevel
) - 4);
6054 pSMB
->DataCount
= 0;
6055 pSMB
->DataOffset
= 0;
6056 pSMB
->SetupCount
= 1;
6057 pSMB
->Reserved3
= 0;
6058 pSMB
->SubCommand
= cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION
);
6059 byte_count
= params
+ 1 /* pad */ ;
6060 pSMB
->TotalParameterCount
= cpu_to_le16(params
);
6061 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
6062 pSMB
->InformationLevel
= cpu_to_le16(SMB_INFO_QUERY_ALL_EAS
);
6063 pSMB
->Reserved4
= 0;
6064 inc_rfc1001_len(pSMB
, byte_count
);
6065 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
6067 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
6068 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
6070 cifs_dbg(FYI
, "Send error in QueryAllEAs = %d\n", rc
);
6075 /* BB also check enough total bytes returned */
6076 /* BB we need to improve the validity checking
6077 of these trans2 responses */
6079 rc
= validate_t2((struct smb_t2_rsp
*)pSMBr
);
6080 if (rc
|| get_bcc(&pSMBr
->hdr
) < 4) {
6081 rc
= -EIO
; /* bad smb */
6085 /* check that length of list is not more than bcc */
6086 /* check that each entry does not go beyond length
6088 /* check that each element of each entry does not
6089 go beyond end of list */
6090 /* validate_trans2_offsets() */
6091 /* BB check if start of smb + data_offset > &bcc+ bcc */
6093 data_offset
= le16_to_cpu(pSMBr
->t2
.DataOffset
);
6094 ea_response_data
= (struct fealist
*)
6095 (((char *) &pSMBr
->hdr
.Protocol
) + data_offset
);
6097 list_len
= le32_to_cpu(ea_response_data
->list_len
);
6098 cifs_dbg(FYI
, "ea length %d\n", list_len
);
6099 if (list_len
<= 8) {
6100 cifs_dbg(FYI
, "empty EA list returned from server\n");
6104 /* make sure list_len doesn't go past end of SMB */
6105 end_of_smb
= (char *)pByteArea(&pSMBr
->hdr
) + get_bcc(&pSMBr
->hdr
);
6106 if ((char *)ea_response_data
+ list_len
> end_of_smb
) {
6107 cifs_dbg(FYI
, "EA list appears to go beyond SMB\n");
6112 /* account for ea list len */
6114 temp_fea
= ea_response_data
->list
;
6115 temp_ptr
= (char *)temp_fea
;
6116 while (list_len
> 0) {
6117 unsigned int name_len
;
6122 /* make sure we can read name_len and value_len */
6124 cifs_dbg(FYI
, "EA entry goes beyond length of list\n");
6129 name_len
= temp_fea
->name_len
;
6130 value_len
= le16_to_cpu(temp_fea
->value_len
);
6131 list_len
-= name_len
+ 1 + value_len
;
6133 cifs_dbg(FYI
, "EA entry goes beyond length of list\n");
6139 if (ea_name_len
== name_len
&&
6140 memcmp(ea_name
, temp_ptr
, name_len
) == 0) {
6141 temp_ptr
+= name_len
+ 1;
6145 if ((size_t)value_len
> buf_size
) {
6149 memcpy(EAData
, temp_ptr
, value_len
);
6153 /* account for prefix user. and trailing null */
6154 rc
+= (5 + 1 + name_len
);
6155 if (rc
< (int) buf_size
) {
6156 memcpy(EAData
, "user.", 5);
6158 memcpy(EAData
, temp_ptr
, name_len
);
6160 /* null terminate name */
6163 } else if (buf_size
== 0) {
6164 /* skip copy - calc size only */
6166 /* stop before overrun buffer */
6171 temp_ptr
+= name_len
+ 1 + value_len
;
6172 temp_fea
= (struct fea
*)temp_ptr
;
6175 /* didn't find the named attribute */
6180 cifs_buf_release(pSMB
);
6188 CIFSSMBSetEA(const unsigned int xid
, struct cifs_tcon
*tcon
,
6189 const char *fileName
, const char *ea_name
, const void *ea_value
,
6190 const __u16 ea_value_len
, const struct nls_table
*nls_codepage
,
6193 struct smb_com_transaction2_spi_req
*pSMB
= NULL
;
6194 struct smb_com_transaction2_spi_rsp
*pSMBr
= NULL
;
6195 struct fealist
*parm_data
;
6198 int bytes_returned
= 0;
6199 __u16 params
, param_offset
, byte_count
, offset
, count
;
6201 cifs_dbg(FYI
, "In SetEA\n");
6203 rc
= smb_init(SMB_COM_TRANSACTION2
, 15, tcon
, (void **) &pSMB
,
6208 if (pSMB
->hdr
.Flags2
& SMBFLG2_UNICODE
) {
6210 cifsConvertToUTF16((__le16
*) pSMB
->FileName
, fileName
,
6211 PATH_MAX
, nls_codepage
, remap
);
6212 name_len
++; /* trailing null */
6214 } else { /* BB improve the check for buffer overruns BB */
6215 name_len
= strnlen(fileName
, PATH_MAX
);
6216 name_len
++; /* trailing null */
6217 strncpy(pSMB
->FileName
, fileName
, name_len
);
6220 params
= 6 + name_len
;
6222 /* done calculating parms using name_len of file name,
6223 now use name_len to calculate length of ea name
6224 we are going to create in the inode xattrs */
6225 if (ea_name
== NULL
)
6228 name_len
= strnlen(ea_name
, 255);
6230 count
= sizeof(*parm_data
) + ea_value_len
+ name_len
;
6231 pSMB
->MaxParameterCount
= cpu_to_le16(2);
6232 /* BB find max SMB PDU from sess */
6233 pSMB
->MaxDataCount
= cpu_to_le16(1000);
6234 pSMB
->MaxSetupCount
= 0;
6238 pSMB
->Reserved2
= 0;
6239 param_offset
= offsetof(struct smb_com_transaction2_spi_req
,
6240 InformationLevel
) - 4;
6241 offset
= param_offset
+ params
;
6242 pSMB
->InformationLevel
=
6243 cpu_to_le16(SMB_SET_FILE_EA
);
6246 (struct fealist
*) (((char *) &pSMB
->hdr
.Protocol
) +
6248 pSMB
->ParameterOffset
= cpu_to_le16(param_offset
);
6249 pSMB
->DataOffset
= cpu_to_le16(offset
);
6250 pSMB
->SetupCount
= 1;
6251 pSMB
->Reserved3
= 0;
6252 pSMB
->SubCommand
= cpu_to_le16(TRANS2_SET_PATH_INFORMATION
);
6253 byte_count
= 3 /* pad */ + params
+ count
;
6254 pSMB
->DataCount
= cpu_to_le16(count
);
6255 parm_data
->list_len
= cpu_to_le32(count
);
6256 parm_data
->list
[0].EA_flags
= 0;
6257 /* we checked above that name len is less than 255 */
6258 parm_data
->list
[0].name_len
= (__u8
)name_len
;
6259 /* EA names are always ASCII */
6261 strncpy(parm_data
->list
[0].name
, ea_name
, name_len
);
6262 parm_data
->list
[0].name
[name_len
] = 0;
6263 parm_data
->list
[0].value_len
= cpu_to_le16(ea_value_len
);
6264 /* caller ensures that ea_value_len is less than 64K but
6265 we need to ensure that it fits within the smb */
6267 /*BB add length check to see if it would fit in
6268 negotiated SMB buffer size BB */
6269 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6271 memcpy(parm_data
->list
[0].name
+name_len
+1,
6272 ea_value
, ea_value_len
);
6274 pSMB
->TotalDataCount
= pSMB
->DataCount
;
6275 pSMB
->ParameterCount
= cpu_to_le16(params
);
6276 pSMB
->TotalParameterCount
= pSMB
->ParameterCount
;
6277 pSMB
->Reserved4
= 0;
6278 inc_rfc1001_len(pSMB
, byte_count
);
6279 pSMB
->ByteCount
= cpu_to_le16(byte_count
);
6280 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
6281 (struct smb_hdr
*) pSMBr
, &bytes_returned
, 0);
6283 cifs_dbg(FYI
, "SetPathInfo (EA) returned %d\n", rc
);
6285 cifs_buf_release(pSMB
);
6294 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6296 * Years ago the kernel added a "dnotify" function for Samba server,
6297 * to allow network clients (such as Windows) to display updated
6298 * lists of files in directory listings automatically when
6299 * files are added by one user when another user has the
6300 * same directory open on their desktop. The Linux cifs kernel
6301 * client hooked into the kernel side of this interface for
6302 * the same reason, but ironically when the VFS moved from
6303 * "dnotify" to "inotify" it became harder to plug in Linux
6304 * network file system clients (the most obvious use case
6305 * for notify interfaces is when multiple users can update
6306 * the contents of the same directory - exactly what network
6307 * file systems can do) although the server (Samba) could
6308 * still use it. For the short term we leave the worker
6309 * function ifdeffed out (below) until inotify is fixed
6310 * in the VFS to make it easier to plug in network file
6311 * system clients. If inotify turns out to be permanently
6312 * incompatible for network fs clients, we could instead simply
6313 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6315 int CIFSSMBNotify(const unsigned int xid
, struct cifs_tcon
*tcon
,
6316 const int notify_subdirs
, const __u16 netfid
,
6317 __u32 filter
, struct file
*pfile
, int multishot
,
6318 const struct nls_table
*nls_codepage
)
6321 struct smb_com_transaction_change_notify_req
*pSMB
= NULL
;
6322 struct smb_com_ntransaction_change_notify_rsp
*pSMBr
= NULL
;
6323 struct dir_notify_req
*dnotify_req
;
6326 cifs_dbg(FYI
, "In CIFSSMBNotify for file handle %d\n", (int)netfid
);
6327 rc
= smb_init(SMB_COM_NT_TRANSACT
, 23, tcon
, (void **) &pSMB
,
6332 pSMB
->TotalParameterCount
= 0 ;
6333 pSMB
->TotalDataCount
= 0;
6334 pSMB
->MaxParameterCount
= cpu_to_le32(2);
6335 pSMB
->MaxDataCount
= cpu_to_le32(CIFSMaxBufSize
& 0xFFFFFF00);
6336 pSMB
->MaxSetupCount
= 4;
6338 pSMB
->ParameterOffset
= 0;
6339 pSMB
->DataCount
= 0;
6340 pSMB
->DataOffset
= 0;
6341 pSMB
->SetupCount
= 4; /* single byte does not need le conversion */
6342 pSMB
->SubCommand
= cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE
);
6343 pSMB
->ParameterCount
= pSMB
->TotalParameterCount
;
6345 pSMB
->WatchTree
= 1; /* one byte - no le conversion needed */
6346 pSMB
->Reserved2
= 0;
6347 pSMB
->CompletionFilter
= cpu_to_le32(filter
);
6348 pSMB
->Fid
= netfid
; /* file handle always le */
6349 pSMB
->ByteCount
= 0;
6351 rc
= SendReceive(xid
, tcon
->ses
, (struct smb_hdr
*) pSMB
,
6352 (struct smb_hdr
*)pSMBr
, &bytes_returned
,
6355 cifs_dbg(FYI
, "Error in Notify = %d\n", rc
);
6357 /* Add file to outstanding requests */
6358 /* BB change to kmem cache alloc */
6359 dnotify_req
= kmalloc(
6360 sizeof(struct dir_notify_req
),
6363 dnotify_req
->Pid
= pSMB
->hdr
.Pid
;
6364 dnotify_req
->PidHigh
= pSMB
->hdr
.PidHigh
;
6365 dnotify_req
->Mid
= pSMB
->hdr
.Mid
;
6366 dnotify_req
->Tid
= pSMB
->hdr
.Tid
;
6367 dnotify_req
->Uid
= pSMB
->hdr
.Uid
;
6368 dnotify_req
->netfid
= netfid
;
6369 dnotify_req
->pfile
= pfile
;
6370 dnotify_req
->filter
= filter
;
6371 dnotify_req
->multishot
= multishot
;
6372 spin_lock(&GlobalMid_Lock
);
6373 list_add_tail(&dnotify_req
->lhead
,
6374 &GlobalDnotifyReqList
);
6375 spin_unlock(&GlobalMid_Lock
);
6379 cifs_buf_release(pSMB
);
6382 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */