1 // SPDX-License-Identifier: LGPL-2.1
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
11 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */
12 /* These are mostly routines that operate on a pathname, or on a tree id */
13 /* (mounted volume), but there are eight handle based routines which must be */
14 /* treated slightly differently for reconnection purposes since we never */
15 /* want to reuse a stale file handle and only the caller knows the file info */
18 #include <linux/filelock.h>
19 #include <linux/kernel.h>
20 #include <linux/vfs.h>
21 #include <linux/slab.h>
22 #include <linux/posix_acl_xattr.h>
23 #include <linux/pagemap.h>
24 #include <linux/swap.h>
25 #include <linux/task_io_accounting_ops.h>
26 #include <linux/uaccess.h>
31 #include "cifsproto.h"
32 #include "cifs_unicode.h"
33 #include "cifs_debug.h"
35 #include "smbdirect.h"
36 #ifdef CONFIG_CIFS_DFS_UPCALL
37 #include "dfs_cache.h"
40 #ifdef CONFIG_CIFS_POSIX
45 {CIFS_PROT, "\2NT LM 0.12"},
46 {POSIX_PROT, "\2POSIX 2"},
54 {CIFS_PROT, "\2NT LM 0.12"},
59 /* define the number of elements in the cifs dialect array */
60 #ifdef CONFIG_CIFS_POSIX
61 #define CIFS_NUM_PROT 2
63 #define CIFS_NUM_PROT 1
64 #endif /* CIFS_POSIX */
67 /* reconnect the socket, tcon, and smb session if needed */
69 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
73 struct TCP_Server_Info *server;
74 struct nls_table *nls_codepage = NULL;
77 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
78 * tcp and smb session status done differently for those three - in the
88 * only tree disconnect, open, and write, (and ulogoff which does not
89 * have tcon) are allowed as we start umount
91 spin_lock(&tcon->tc_lock);
92 if (tcon->status == TID_EXITING) {
93 if (smb_command != SMB_COM_TREE_DISCONNECT) {
94 spin_unlock(&tcon->tc_lock);
95 cifs_dbg(FYI, "can not send cmd %d while umounting\n",
100 spin_unlock(&tcon->tc_lock);
103 rc = cifs_wait_for_server_reconnect(server, tcon->retry);
107 spin_lock(&ses->chan_lock);
108 if (!cifs_chan_needs_reconnect(ses, server) && !tcon->need_reconnect) {
109 spin_unlock(&ses->chan_lock);
112 spin_unlock(&ses->chan_lock);
114 mutex_lock(&ses->session_mutex);
116 * Recheck after acquire mutex. If another thread is negotiating
117 * and the server never sends an answer the socket will be closed
118 * and tcpStatus set to reconnect.
120 spin_lock(&server->srv_lock);
121 if (server->tcpStatus == CifsNeedReconnect) {
122 spin_unlock(&server->srv_lock);
123 mutex_unlock(&ses->session_mutex);
130 spin_unlock(&server->srv_lock);
132 nls_codepage = ses->local_nls;
135 * need to prevent multiple threads trying to simultaneously
136 * reconnect the same SMB session
138 spin_lock(&ses->ses_lock);
139 spin_lock(&ses->chan_lock);
140 if (!cifs_chan_needs_reconnect(ses, server) &&
141 ses->ses_status == SES_GOOD) {
142 spin_unlock(&ses->chan_lock);
143 spin_unlock(&ses->ses_lock);
145 /* this means that we only need to tree connect */
146 if (tcon->need_reconnect)
147 goto skip_sess_setup;
149 mutex_unlock(&ses->session_mutex);
152 spin_unlock(&ses->chan_lock);
153 spin_unlock(&ses->ses_lock);
155 rc = cifs_negotiate_protocol(0, ses, server);
157 rc = cifs_setup_session(0, ses, server, nls_codepage);
159 /* do we need to reconnect tcon? */
160 if (rc || !tcon->need_reconnect) {
161 mutex_unlock(&ses->session_mutex);
166 cifs_mark_open_files_invalid(tcon);
167 rc = cifs_tree_connect(0, tcon, nls_codepage);
168 mutex_unlock(&ses->session_mutex);
169 cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc);
172 pr_warn_once("reconnect tcon failed rc = %d\n", rc);
176 atomic_inc(&tconInfoReconnectCount);
178 /* tell server Unix caps we support */
180 reset_cifs_unix_caps(0, tcon, NULL, NULL);
183 * Removed call to reopen open files here. It is safer (and faster) to
184 * reopen files one at a time as needed in read and write.
186 * FIXME: what about file locks? don't we need to reclaim them ASAP?
191 * Check if handle based operation so we know whether we can continue
192 * or not without returning to caller to reset file handle
194 switch (smb_command) {
195 case SMB_COM_READ_ANDX:
196 case SMB_COM_WRITE_ANDX:
198 case SMB_COM_FIND_CLOSE2:
199 case SMB_COM_LOCKING_ANDX:
206 /* Allocate and return pointer to an SMB request buffer, and set basic
207 SMB information in the SMB header. If the return code is zero, this
208 function must have filled in request_buf pointer */
210 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
215 rc = cifs_reconnect_tcon(tcon, smb_command);
219 *request_buf = cifs_small_buf_get();
220 if (*request_buf == NULL) {
221 /* BB should we add a retry in here if not a writepage? */
225 header_assemble((struct smb_hdr *) *request_buf, smb_command,
229 cifs_stats_inc(&tcon->num_smbs_sent);
235 small_smb_init_no_tc(const int smb_command, const int wct,
236 struct cifs_ses *ses, void **request_buf)
239 struct smb_hdr *buffer;
241 rc = small_smb_init(smb_command, wct, NULL, request_buf);
245 buffer = (struct smb_hdr *)*request_buf;
246 buffer->Mid = get_next_mid(ses->server);
247 if (ses->capabilities & CAP_UNICODE)
248 buffer->Flags2 |= SMBFLG2_UNICODE;
249 if (ses->capabilities & CAP_STATUS32)
250 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
252 /* uid, tid can stay at zero as set in header assemble */
254 /* BB add support for turning on the signing when
255 this function is used after 1st of session setup requests */
260 /* If the return code is zero, this function must fill in request_buf pointer */
262 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
263 void **request_buf, void **response_buf)
265 *request_buf = cifs_buf_get();
266 if (*request_buf == NULL) {
267 /* BB should we add a retry in here if not a writepage? */
270 /* Although the original thought was we needed the response buf for */
271 /* potential retries of smb operations it turns out we can determine */
272 /* from the mid flags when the request buffer can be resent without */
273 /* having to use a second distinct buffer for the response */
275 *response_buf = *request_buf;
277 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
281 cifs_stats_inc(&tcon->num_smbs_sent);
286 /* If the return code is zero, this function must fill in request_buf pointer */
288 smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
289 void **request_buf, void **response_buf)
293 rc = cifs_reconnect_tcon(tcon, smb_command);
297 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
301 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
302 void **request_buf, void **response_buf)
304 spin_lock(&tcon->ses->chan_lock);
305 if (cifs_chan_needs_reconnect(tcon->ses, tcon->ses->server) ||
306 tcon->need_reconnect) {
307 spin_unlock(&tcon->ses->chan_lock);
310 spin_unlock(&tcon->ses->chan_lock);
312 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
315 static int validate_t2(struct smb_t2_rsp *pSMB)
317 unsigned int total_size;
319 /* check for plausible wct */
320 if (pSMB->hdr.WordCount < 10)
323 /* check for parm and data offset going beyond end of smb */
324 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
325 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
328 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
329 if (total_size >= 512)
332 /* check that bcc is at least as big as parms + data, and that it is
333 * less than negotiated smb buffer
335 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
336 if (total_size > get_bcc(&pSMB->hdr) ||
337 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
342 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
343 sizeof(struct smb_t2_rsp) + 16);
348 decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
352 char *guid = pSMBr->u.extended_response.GUID;
353 struct TCP_Server_Info *server = ses->server;
355 count = get_bcc(&pSMBr->hdr);
356 if (count < SMB1_CLIENT_GUID_SIZE)
359 spin_lock(&cifs_tcp_ses_lock);
360 if (server->srv_count > 1) {
361 spin_unlock(&cifs_tcp_ses_lock);
362 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
363 cifs_dbg(FYI, "server UID changed\n");
364 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
367 spin_unlock(&cifs_tcp_ses_lock);
368 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
371 if (count == SMB1_CLIENT_GUID_SIZE) {
372 server->sec_ntlmssp = true;
374 count -= SMB1_CLIENT_GUID_SIZE;
375 rc = decode_negTokenInit(
376 pSMBr->u.extended_response.SecurityBlob, count, server);
385 should_set_ext_sec_flag(enum securityEnum sectype)
392 if (global_secflags &
393 (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP))
402 CIFSSMBNegotiate(const unsigned int xid,
403 struct cifs_ses *ses,
404 struct TCP_Server_Info *server)
407 NEGOTIATE_RSP *pSMBr;
414 WARN(1, "%s: server is NULL!\n", __func__);
418 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
419 (void **) &pSMB, (void **) &pSMBr);
423 pSMB->hdr.Mid = get_next_mid(server);
424 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
426 if (should_set_ext_sec_flag(ses->sectype)) {
427 cifs_dbg(FYI, "Requesting extended security\n");
428 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
433 * We know that all the name entries in the protocols array
434 * are short (< 16 bytes anyway) and are NUL terminated.
436 for (i = 0; i < CIFS_NUM_PROT; i++) {
437 size_t len = strlen(protocols[i].name) + 1;
439 memcpy(&pSMB->DialectsArray[count], protocols[i].name, len);
442 inc_rfc1001_len(pSMB, count);
443 pSMB->ByteCount = cpu_to_le16(count);
445 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
446 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
450 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
451 cifs_dbg(FYI, "Dialect: %d\n", server->dialect);
452 /* Check wct = 1 error case */
453 if ((pSMBr->hdr.WordCount <= 13) || (server->dialect == BAD_PROT)) {
454 /* core returns wct = 1, but we do not ask for core - otherwise
455 small wct just comes when dialect index is -1 indicating we
456 could not negotiate a common dialect */
459 } else if (pSMBr->hdr.WordCount != 17) {
464 /* else wct == 17, NTLM or better */
466 server->sec_mode = pSMBr->SecurityMode;
467 if ((server->sec_mode & SECMODE_USER) == 0)
468 cifs_dbg(FYI, "share mode security\n");
470 /* one byte, so no need to convert this or EncryptionKeyLen from
472 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
474 set_credits(server, server->maxReq);
475 /* probably no need to store and check maxvcs */
476 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
477 /* set up max_read for readahead check */
478 server->max_read = server->maxBuf;
479 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
480 cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
481 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
482 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
483 server->timeAdj *= 60;
485 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
486 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
487 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
488 CIFS_CRYPTO_KEY_SIZE);
489 } else if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
490 server->capabilities & CAP_EXTENDED_SECURITY) {
491 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
492 rc = decode_ext_sec_blob(ses, pSMBr);
493 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
494 rc = -EIO; /* no crypt key only if plain text pwd */
496 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
497 server->capabilities &= ~CAP_EXTENDED_SECURITY;
501 rc = cifs_enable_signing(server, ses->sign);
503 cifs_buf_release(pSMB);
505 cifs_dbg(FYI, "negprot rc %d\n", rc);
510 CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
512 struct smb_hdr *smb_buffer;
515 cifs_dbg(FYI, "In tree disconnect\n");
517 /* BB: do we need to check this? These should never be NULL. */
518 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
522 * No need to return error on this operation if tid invalidated and
523 * closed on server already e.g. due to tcp session crashing. Also,
524 * the tcon is no longer on the list, so no need to take lock before
527 spin_lock(&tcon->ses->chan_lock);
528 if ((tcon->need_reconnect) || CIFS_ALL_CHANS_NEED_RECONNECT(tcon->ses)) {
529 spin_unlock(&tcon->ses->chan_lock);
532 spin_unlock(&tcon->ses->chan_lock);
534 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
535 (void **)&smb_buffer);
539 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
540 cifs_small_buf_release(smb_buffer);
542 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc);
544 /* No need to return error on this operation if tid invalidated and
545 closed on server already e.g. due to tcp session crashing */
553 * This is a no-op for now. We're not really interested in the reply, but
554 * rather in the fact that the server sent one and that server->lstrp
557 * FIXME: maybe we should consider checking that the reply matches request?
560 cifs_echo_callback(struct mid_q_entry *mid)
562 struct TCP_Server_Info *server = mid->callback_data;
563 struct cifs_credits credits = { .value = 1, .instance = 0 };
566 add_credits(server, &credits, CIFS_ECHO_OP);
570 CIFSSMBEcho(struct TCP_Server_Info *server)
575 struct smb_rqst rqst = { .rq_iov = iov,
578 cifs_dbg(FYI, "In echo request\n");
580 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
584 if (server->capabilities & CAP_UNICODE)
585 smb->hdr.Flags2 |= SMBFLG2_UNICODE;
587 /* set up echo request */
588 smb->hdr.Tid = 0xffff;
589 smb->hdr.WordCount = 1;
590 put_unaligned_le16(1, &smb->EchoCount);
591 put_bcc(1, &smb->hdr);
593 inc_rfc1001_len(smb, 3);
596 iov[0].iov_base = smb;
597 iov[1].iov_len = get_rfc1002_length(smb);
598 iov[1].iov_base = (char *)smb + 4;
600 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback, NULL,
601 server, CIFS_NON_BLOCKING | CIFS_ECHO_OP, NULL);
603 cifs_dbg(FYI, "Echo request failed: %d\n", rc);
605 cifs_small_buf_release(smb);
611 CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
613 LOGOFF_ANDX_REQ *pSMB;
616 cifs_dbg(FYI, "In SMBLogoff for session disconnect\n");
619 * BB: do we need to check validity of ses and server? They should
620 * always be valid since we have an active reference. If not, that
621 * should probably be a BUG()
623 if (!ses || !ses->server)
626 mutex_lock(&ses->session_mutex);
627 spin_lock(&ses->chan_lock);
628 if (CIFS_ALL_CHANS_NEED_RECONNECT(ses)) {
629 spin_unlock(&ses->chan_lock);
630 goto session_already_dead; /* no need to send SMBlogoff if uid
631 already closed due to reconnect */
633 spin_unlock(&ses->chan_lock);
635 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
637 mutex_unlock(&ses->session_mutex);
641 pSMB->hdr.Mid = get_next_mid(ses->server);
643 if (ses->server->sign)
644 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
646 pSMB->hdr.Uid = ses->Suid;
648 pSMB->AndXCommand = 0xFF;
649 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
650 cifs_small_buf_release(pSMB);
651 session_already_dead:
652 mutex_unlock(&ses->session_mutex);
654 /* if session dead then we do not need to do ulogoff,
655 since server closed smb session, no sense reporting
663 CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
664 const char *fileName, __u16 type,
665 const struct nls_table *nls_codepage, int remap)
667 TRANSACTION2_SPI_REQ *pSMB = NULL;
668 TRANSACTION2_SPI_RSP *pSMBr = NULL;
669 struct unlink_psx_rq *pRqD;
672 int bytes_returned = 0;
673 __u16 params, param_offset, offset, byte_count;
675 cifs_dbg(FYI, "In POSIX delete\n");
677 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
682 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
684 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
685 PATH_MAX, nls_codepage, remap);
686 name_len++; /* trailing null */
689 name_len = copy_path_name(pSMB->FileName, fileName);
692 params = 6 + name_len;
693 pSMB->MaxParameterCount = cpu_to_le16(2);
694 pSMB->MaxDataCount = 0; /* BB double check this with jra */
695 pSMB->MaxSetupCount = 0;
700 param_offset = offsetof(struct smb_com_transaction2_spi_req,
701 InformationLevel) - 4;
702 offset = param_offset + params;
704 /* Setup pointer to Request Data (inode type).
705 * Note that SMB offsets are from the beginning of SMB which is 4 bytes
706 * in, after RFC1001 field
708 pRqD = (struct unlink_psx_rq *)((char *)(pSMB) + offset + 4);
709 pRqD->type = cpu_to_le16(type);
710 pSMB->ParameterOffset = cpu_to_le16(param_offset);
711 pSMB->DataOffset = cpu_to_le16(offset);
712 pSMB->SetupCount = 1;
714 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
715 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
717 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
718 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
719 pSMB->ParameterCount = cpu_to_le16(params);
720 pSMB->TotalParameterCount = pSMB->ParameterCount;
721 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
723 inc_rfc1001_len(pSMB, byte_count);
724 pSMB->ByteCount = cpu_to_le16(byte_count);
725 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
726 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
728 cifs_dbg(FYI, "Posix delete returned %d\n", rc);
729 cifs_buf_release(pSMB);
731 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
740 CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
741 struct cifs_sb_info *cifs_sb)
743 DELETE_FILE_REQ *pSMB = NULL;
744 DELETE_FILE_RSP *pSMBr = NULL;
748 int remap = cifs_remap(cifs_sb);
751 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
756 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
757 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
758 PATH_MAX, cifs_sb->local_nls,
760 name_len++; /* trailing null */
763 name_len = copy_path_name(pSMB->fileName, name);
765 pSMB->SearchAttributes =
766 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
767 pSMB->BufferFormat = 0x04;
768 inc_rfc1001_len(pSMB, name_len + 1);
769 pSMB->ByteCount = cpu_to_le16(name_len + 1);
770 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
771 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
772 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
774 cifs_dbg(FYI, "Error in RMFile = %d\n", rc);
776 cifs_buf_release(pSMB);
784 CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
785 struct cifs_sb_info *cifs_sb)
787 DELETE_DIRECTORY_REQ *pSMB = NULL;
788 DELETE_DIRECTORY_RSP *pSMBr = NULL;
792 int remap = cifs_remap(cifs_sb);
794 cifs_dbg(FYI, "In CIFSSMBRmDir\n");
796 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
801 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
802 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
803 PATH_MAX, cifs_sb->local_nls,
805 name_len++; /* trailing null */
808 name_len = copy_path_name(pSMB->DirName, name);
811 pSMB->BufferFormat = 0x04;
812 inc_rfc1001_len(pSMB, name_len + 1);
813 pSMB->ByteCount = cpu_to_le16(name_len + 1);
814 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
815 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
816 cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
818 cifs_dbg(FYI, "Error in RMDir = %d\n", rc);
820 cifs_buf_release(pSMB);
827 CIFSSMBMkDir(const unsigned int xid, struct inode *inode, umode_t mode,
828 struct cifs_tcon *tcon, const char *name,
829 struct cifs_sb_info *cifs_sb)
832 CREATE_DIRECTORY_REQ *pSMB = NULL;
833 CREATE_DIRECTORY_RSP *pSMBr = NULL;
836 int remap = cifs_remap(cifs_sb);
838 cifs_dbg(FYI, "In CIFSSMBMkDir\n");
840 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
845 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
846 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
847 PATH_MAX, cifs_sb->local_nls,
849 name_len++; /* trailing null */
852 name_len = copy_path_name(pSMB->DirName, name);
855 pSMB->BufferFormat = 0x04;
856 inc_rfc1001_len(pSMB, name_len + 1);
857 pSMB->ByteCount = cpu_to_le16(name_len + 1);
858 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
859 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
860 cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
862 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc);
864 cifs_buf_release(pSMB);
871 CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
872 __u32 posix_flags, __u64 mode, __u16 *netfid,
873 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
874 const char *name, const struct nls_table *nls_codepage,
877 TRANSACTION2_SPI_REQ *pSMB = NULL;
878 TRANSACTION2_SPI_RSP *pSMBr = NULL;
881 int bytes_returned = 0;
882 __u16 params, param_offset, offset, byte_count, count;
884 OPEN_PSX_RSP *psx_rsp;
886 cifs_dbg(FYI, "In POSIX Create\n");
888 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
893 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
895 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
896 PATH_MAX, nls_codepage, remap);
897 name_len++; /* trailing null */
900 name_len = copy_path_name(pSMB->FileName, name);
903 params = 6 + name_len;
904 count = sizeof(OPEN_PSX_REQ);
905 pSMB->MaxParameterCount = cpu_to_le16(2);
906 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
907 pSMB->MaxSetupCount = 0;
912 param_offset = offsetof(struct smb_com_transaction2_spi_req,
913 InformationLevel) - 4;
914 offset = param_offset + params;
915 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
916 pdata = (OPEN_PSX_REQ *)((char *)(pSMB) + offset + 4);
917 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
918 pdata->Permissions = cpu_to_le64(mode);
919 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
920 pdata->OpenFlags = cpu_to_le32(*pOplock);
921 pSMB->ParameterOffset = cpu_to_le16(param_offset);
922 pSMB->DataOffset = cpu_to_le16(offset);
923 pSMB->SetupCount = 1;
925 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
926 byte_count = 3 /* pad */ + params + count;
928 pSMB->DataCount = cpu_to_le16(count);
929 pSMB->ParameterCount = cpu_to_le16(params);
930 pSMB->TotalDataCount = pSMB->DataCount;
931 pSMB->TotalParameterCount = pSMB->ParameterCount;
932 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
934 inc_rfc1001_len(pSMB, byte_count);
935 pSMB->ByteCount = cpu_to_le16(byte_count);
936 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
937 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
939 cifs_dbg(FYI, "Posix create returned %d\n", rc);
943 cifs_dbg(FYI, "copying inode info\n");
944 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
946 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
947 rc = -EIO; /* bad smb */
951 /* copy return information to pRetData */
952 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
953 + le16_to_cpu(pSMBr->t2.DataOffset));
955 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
957 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
958 /* Let caller know file was created so we can set the mode. */
959 /* Do we care about the CreateAction in any other cases? */
960 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
961 *pOplock |= CIFS_CREATE_ACTION;
962 /* check to make sure response data is there */
963 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
964 pRetData->Type = cpu_to_le32(-1); /* unknown */
965 cifs_dbg(NOISY, "unknown type\n");
967 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
968 + sizeof(FILE_UNIX_BASIC_INFO)) {
969 cifs_dbg(VFS, "Open response data too small\n");
970 pRetData->Type = cpu_to_le32(-1);
973 memcpy((char *) pRetData,
974 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
975 sizeof(FILE_UNIX_BASIC_INFO));
979 cifs_buf_release(pSMB);
981 if (posix_flags & SMB_O_DIRECTORY)
982 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
984 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
992 static __u16 convert_disposition(int disposition)
996 switch (disposition) {
998 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1001 ofun = SMBOPEN_OAPPEND;
1004 ofun = SMBOPEN_OCREATE;
1007 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1009 case FILE_OVERWRITE:
1010 ofun = SMBOPEN_OTRUNC;
1012 case FILE_OVERWRITE_IF:
1013 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1016 cifs_dbg(FYI, "unknown disposition %d\n", disposition);
1017 ofun = SMBOPEN_OAPPEND; /* regular open */
1023 access_flags_to_smbopen_mode(const int access_flags)
1025 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1027 if (masked_flags == GENERIC_READ)
1028 return SMBOPEN_READ;
1029 else if (masked_flags == GENERIC_WRITE)
1030 return SMBOPEN_WRITE;
1032 /* just go for read/write */
1033 return SMBOPEN_READWRITE;
1037 SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
1038 const char *fileName, const int openDisposition,
1039 const int access_flags, const int create_options, __u16 *netfid,
1040 int *pOplock, FILE_ALL_INFO *pfile_info,
1041 const struct nls_table *nls_codepage, int remap)
1044 OPENX_REQ *pSMB = NULL;
1045 OPENX_RSP *pSMBr = NULL;
1051 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1056 pSMB->AndXCommand = 0xFF; /* none */
1058 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1059 count = 1; /* account for one byte pad to word boundary */
1061 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1062 fileName, PATH_MAX, nls_codepage, remap);
1063 name_len++; /* trailing null */
1066 count = 0; /* no pad */
1067 name_len = copy_path_name(pSMB->fileName, fileName);
1069 if (*pOplock & REQ_OPLOCK)
1070 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1071 else if (*pOplock & REQ_BATCHOPLOCK)
1072 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1074 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1075 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1076 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1077 /* set file as system file if special file such
1078 as fifo and server expecting SFU style and
1079 no Unix extensions */
1081 if (create_options & CREATE_OPTION_SPECIAL)
1082 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1083 else /* BB FIXME BB */
1084 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1086 if (create_options & CREATE_OPTION_READONLY)
1087 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1090 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1091 CREATE_OPTIONS_MASK); */
1092 /* BB FIXME END BB */
1094 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1095 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1097 inc_rfc1001_len(pSMB, count);
1099 pSMB->ByteCount = cpu_to_le16(count);
1100 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1101 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1102 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1104 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1106 /* BB verify if wct == 15 */
1108 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1110 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1111 /* Let caller know file was created so we can set the mode. */
1112 /* Do we care about the CreateAction in any other cases? */
1114 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1115 *pOplock |= CIFS_CREATE_ACTION; */
1119 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1120 pfile_info->LastAccessTime = 0; /* BB fixme */
1121 pfile_info->LastWriteTime = 0; /* BB fixme */
1122 pfile_info->ChangeTime = 0; /* BB fixme */
1123 pfile_info->Attributes =
1124 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1125 /* the file_info buf is endian converted by caller */
1126 pfile_info->AllocationSize =
1127 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1128 pfile_info->EndOfFile = pfile_info->AllocationSize;
1129 pfile_info->NumberOfLinks = cpu_to_le32(1);
1130 pfile_info->DeletePending = 0;
1134 cifs_buf_release(pSMB);
1141 CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,
1145 OPEN_REQ *req = NULL;
1146 OPEN_RSP *rsp = NULL;
1150 struct cifs_sb_info *cifs_sb = oparms->cifs_sb;
1151 struct cifs_tcon *tcon = oparms->tcon;
1152 int remap = cifs_remap(cifs_sb);
1153 const struct nls_table *nls = cifs_sb->local_nls;
1154 int create_options = oparms->create_options;
1155 int desired_access = oparms->desired_access;
1156 int disposition = oparms->disposition;
1157 const char *path = oparms->path;
1160 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **)&req,
1165 /* no commands go after this */
1166 req->AndXCommand = 0xFF;
1168 if (req->hdr.Flags2 & SMBFLG2_UNICODE) {
1169 /* account for one byte pad to word boundary */
1171 name_len = cifsConvertToUTF16((__le16 *)(req->fileName + 1),
1172 path, PATH_MAX, nls, remap);
1176 req->NameLength = cpu_to_le16(name_len);
1178 /* BB improve check for buffer overruns BB */
1181 name_len = copy_path_name(req->fileName, path);
1182 req->NameLength = cpu_to_le16(name_len);
1185 if (*oplock & REQ_OPLOCK)
1186 req->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1187 else if (*oplock & REQ_BATCHOPLOCK)
1188 req->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1190 req->DesiredAccess = cpu_to_le32(desired_access);
1191 req->AllocationSize = 0;
1194 * Set file as system file if special file such as fifo and server
1195 * expecting SFU style and no Unix extensions.
1197 if (create_options & CREATE_OPTION_SPECIAL)
1198 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1200 req->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1203 * XP does not handle ATTR_POSIX_SEMANTICS but it helps speed up case
1204 * sensitive checks for other servers such as Samba.
1206 if (tcon->ses->capabilities & CAP_UNIX)
1207 req->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1209 if (create_options & CREATE_OPTION_READONLY)
1210 req->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1212 req->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1213 req->CreateDisposition = cpu_to_le32(disposition);
1214 req->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1216 /* BB Expirement with various impersonation levels and verify */
1217 req->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1218 req->SecurityFlags = SECURITY_CONTEXT_TRACKING|SECURITY_EFFECTIVE_ONLY;
1221 inc_rfc1001_len(req, count);
1223 req->ByteCount = cpu_to_le16(count);
1224 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)req,
1225 (struct smb_hdr *)rsp, &bytes_returned, 0);
1226 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1228 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1229 cifs_buf_release(req);
1235 /* 1 byte no need to le_to_cpu */
1236 *oplock = rsp->OplockLevel;
1237 /* cifs fid stays in le */
1238 oparms->fid->netfid = rsp->Fid;
1239 oparms->fid->access = desired_access;
1241 /* Let caller know file was created so we can set the mode. */
1242 /* Do we care about the CreateAction in any other cases? */
1243 if (cpu_to_le32(FILE_CREATE) == rsp->CreateAction)
1244 *oplock |= CIFS_CREATE_ACTION;
1247 /* copy commonly used attributes */
1248 memcpy(&buf->common_attributes,
1249 &rsp->common_attributes,
1250 sizeof(buf->common_attributes));
1251 /* the file_info buf is endian converted by caller */
1252 buf->AllocationSize = rsp->AllocationSize;
1253 buf->EndOfFile = rsp->EndOfFile;
1254 buf->NumberOfLinks = cpu_to_le32(1);
1255 buf->DeletePending = 0;
1258 cifs_buf_release(req);
1263 cifs_readv_callback(struct mid_q_entry *mid)
1265 struct cifs_readdata *rdata = mid->callback_data;
1266 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1267 struct TCP_Server_Info *server = tcon->ses->server;
1268 struct smb_rqst rqst = { .rq_iov = rdata->iov,
1270 .rq_iter_size = iov_iter_count(&rdata->iter),
1271 .rq_iter = rdata->iter };
1272 struct cifs_credits credits = { .value = 1, .instance = 0 };
1274 cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1275 __func__, mid->mid, mid->mid_state, rdata->result,
1278 switch (mid->mid_state) {
1279 case MID_RESPONSE_RECEIVED:
1280 /* result already set, check signature */
1284 rc = cifs_verify_signature(&rqst, server,
1285 mid->sequence_number);
1287 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
1290 /* FIXME: should this be counted toward the initiating task? */
1291 task_io_account_read(rdata->got_bytes);
1292 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1294 case MID_REQUEST_SUBMITTED:
1295 case MID_RETRY_NEEDED:
1296 rdata->result = -EAGAIN;
1297 if (server->sign && rdata->got_bytes)
1298 /* reset bytes number since we can not check a sign */
1299 rdata->got_bytes = 0;
1300 /* FIXME: should this be counted toward the initiating task? */
1301 task_io_account_read(rdata->got_bytes);
1302 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1305 rdata->result = -EIO;
1308 queue_work(cifsiod_wq, &rdata->work);
1310 add_credits(server, &credits, 0);
1313 /* cifs_async_readv - send an async write, and set up mid to handle result */
1315 cifs_async_readv(struct cifs_readdata *rdata)
1318 READ_REQ *smb = NULL;
1320 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1321 struct smb_rqst rqst = { .rq_iov = rdata->iov,
1324 cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
1325 __func__, rdata->offset, rdata->bytes);
1327 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1330 wct = 10; /* old style read */
1331 if ((rdata->offset >> 32) > 0) {
1332 /* can not handle this big offset for old */
1337 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1341 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1342 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1344 smb->AndXCommand = 0xFF; /* none */
1345 smb->Fid = rdata->cfile->fid.netfid;
1346 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1348 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1350 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1351 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1355 /* old style read */
1356 struct smb_com_readx_req *smbr =
1357 (struct smb_com_readx_req *)smb;
1358 smbr->ByteCount = 0;
1361 /* 4 for RFC1001 length + 1 for BCC */
1362 rdata->iov[0].iov_base = smb;
1363 rdata->iov[0].iov_len = 4;
1364 rdata->iov[1].iov_base = (char *)smb + 4;
1365 rdata->iov[1].iov_len = get_rfc1002_length(smb);
1367 kref_get(&rdata->refcount);
1368 rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
1369 cifs_readv_callback, NULL, rdata, 0, NULL);
1372 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1374 kref_put(&rdata->refcount, cifs_readdata_release);
1376 cifs_small_buf_release(smb);
1381 CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
1382 unsigned int *nbytes, char **buf, int *pbuf_type)
1385 READ_REQ *pSMB = NULL;
1386 READ_RSP *pSMBr = NULL;
1387 char *pReadData = NULL;
1389 int resp_buf_type = 0;
1391 struct kvec rsp_iov;
1392 __u32 pid = io_parms->pid;
1393 __u16 netfid = io_parms->netfid;
1394 __u64 offset = io_parms->offset;
1395 struct cifs_tcon *tcon = io_parms->tcon;
1396 unsigned int count = io_parms->length;
1398 cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid);
1399 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1402 wct = 10; /* old style read */
1403 if ((offset >> 32) > 0) {
1404 /* can not handle this big offset for old */
1410 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1414 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1415 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1417 /* tcon and ses pointer are checked in smb_init */
1418 if (tcon->ses->server == NULL)
1419 return -ECONNABORTED;
1421 pSMB->AndXCommand = 0xFF; /* none */
1423 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1425 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1427 pSMB->Remaining = 0;
1428 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1429 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1431 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1433 /* old style read */
1434 struct smb_com_readx_req *pSMBW =
1435 (struct smb_com_readx_req *)pSMB;
1436 pSMBW->ByteCount = 0;
1439 iov[0].iov_base = (char *)pSMB;
1440 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1441 rc = SendReceive2(xid, tcon->ses, iov, 1, &resp_buf_type,
1442 CIFS_LOG_ERROR, &rsp_iov);
1443 cifs_small_buf_release(pSMB);
1444 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1445 pSMBr = (READ_RSP *)rsp_iov.iov_base;
1447 cifs_dbg(VFS, "Send error in read = %d\n", rc);
1449 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1450 data_length = data_length << 16;
1451 data_length += le16_to_cpu(pSMBr->DataLength);
1452 *nbytes = data_length;
1454 /*check that DataLength would not go beyond end of SMB */
1455 if ((data_length > CIFSMaxBufSize)
1456 || (data_length > count)) {
1457 cifs_dbg(FYI, "bad length %d for count %d\n",
1458 data_length, count);
1462 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1463 le16_to_cpu(pSMBr->DataOffset);
1464 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1465 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
1467 }*/ /* can not use copy_to_user when using page cache*/
1469 memcpy(*buf, pReadData, data_length);
1474 free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
1475 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1476 /* return buffer to caller to free */
1477 *buf = rsp_iov.iov_base;
1478 if (resp_buf_type == CIFS_SMALL_BUFFER)
1479 *pbuf_type = CIFS_SMALL_BUFFER;
1480 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1481 *pbuf_type = CIFS_LARGE_BUFFER;
1482 } /* else no valid buffer on return - leave as null */
1484 /* Note: On -EAGAIN error only caller can retry on handle based calls
1485 since file handle passed in no longer valid */
1491 CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
1492 unsigned int *nbytes, const char *buf)
1495 WRITE_REQ *pSMB = NULL;
1496 WRITE_RSP *pSMBr = NULL;
1497 int bytes_returned, wct;
1500 __u32 pid = io_parms->pid;
1501 __u16 netfid = io_parms->netfid;
1502 __u64 offset = io_parms->offset;
1503 struct cifs_tcon *tcon = io_parms->tcon;
1504 unsigned int count = io_parms->length;
1508 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
1509 if (tcon->ses == NULL)
1510 return -ECONNABORTED;
1512 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1516 if ((offset >> 32) > 0) {
1517 /* can not handle big offset for old srv */
1522 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1527 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1528 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1530 /* tcon and ses pointer are checked in smb_init */
1531 if (tcon->ses->server == NULL)
1532 return -ECONNABORTED;
1534 pSMB->AndXCommand = 0xFF; /* none */
1536 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1538 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1540 pSMB->Reserved = 0xFFFFFFFF;
1541 pSMB->WriteMode = 0;
1542 pSMB->Remaining = 0;
1544 /* Can increase buffer size if buffer is big enough in some cases ie we
1545 can send more if LARGE_WRITE_X capability returned by the server and if
1546 our buffer is big enough or if we convert to iovecs on socket writes
1547 and eliminate the copy to the CIFS buffer */
1548 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1549 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1551 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1555 if (bytes_sent > count)
1558 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1560 memcpy(pSMB->Data, buf, bytes_sent);
1561 else if (count != 0) {
1563 cifs_buf_release(pSMB);
1565 } /* else setting file size with write of zero bytes */
1567 byte_count = bytes_sent + 1; /* pad */
1568 else /* wct == 12 */
1569 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1571 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1572 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1573 inc_rfc1001_len(pSMB, byte_count);
1576 pSMB->ByteCount = cpu_to_le16(byte_count);
1577 else { /* old style write has byte count 4 bytes earlier
1579 struct smb_com_writex_req *pSMBW =
1580 (struct smb_com_writex_req *)pSMB;
1581 pSMBW->ByteCount = cpu_to_le16(byte_count);
1584 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1585 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1586 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1588 cifs_dbg(FYI, "Send error in write = %d\n", rc);
1590 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1591 *nbytes = (*nbytes) << 16;
1592 *nbytes += le16_to_cpu(pSMBr->Count);
1595 * Mask off high 16 bits when bytes written as returned by the
1596 * server is greater than bytes requested by the client. Some
1597 * OS/2 servers are known to set incorrect CountHigh values.
1599 if (*nbytes > count)
1603 cifs_buf_release(pSMB);
1605 /* Note: On -EAGAIN error only caller can retry on handle based calls
1606 since file handle passed in no longer valid */
1612 * Check the mid_state and signature on received buffer (if any), and queue the
1613 * workqueue completion task.
1616 cifs_writev_callback(struct mid_q_entry *mid)
1618 struct cifs_writedata *wdata = mid->callback_data;
1619 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
1620 unsigned int written;
1621 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
1622 struct cifs_credits credits = { .value = 1, .instance = 0 };
1624 switch (mid->mid_state) {
1625 case MID_RESPONSE_RECEIVED:
1626 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
1627 if (wdata->result != 0)
1630 written = le16_to_cpu(smb->CountHigh);
1632 written += le16_to_cpu(smb->Count);
1634 * Mask off high 16 bits when bytes written as returned
1635 * by the server is greater than bytes requested by the
1636 * client. OS/2 servers are known to set incorrect
1639 if (written > wdata->bytes)
1642 if (written < wdata->bytes)
1643 wdata->result = -ENOSPC;
1645 wdata->bytes = written;
1647 case MID_REQUEST_SUBMITTED:
1648 case MID_RETRY_NEEDED:
1649 wdata->result = -EAGAIN;
1652 wdata->result = -EIO;
1656 queue_work(cifsiod_wq, &wdata->work);
1658 add_credits(tcon->ses->server, &credits, 0);
1661 /* cifs_async_writev - send an async write, and set up mid to handle result */
1663 cifs_async_writev(struct cifs_writedata *wdata,
1664 void (*release)(struct kref *kref))
1667 WRITE_REQ *smb = NULL;
1669 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
1671 struct smb_rqst rqst = { };
1673 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
1677 if (wdata->offset >> 32 > 0) {
1678 /* can not handle big offset for old srv */
1683 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
1685 goto async_writev_out;
1687 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
1688 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
1690 smb->AndXCommand = 0xFF; /* none */
1691 smb->Fid = wdata->cfile->fid.netfid;
1692 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
1694 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
1695 smb->Reserved = 0xFFFFFFFF;
1700 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1702 /* 4 for RFC1001 length + 1 for BCC */
1704 iov[0].iov_base = smb;
1705 iov[1].iov_len = get_rfc1002_length(smb) + 1;
1706 iov[1].iov_base = (char *)smb + 4;
1710 rqst.rq_iter = wdata->iter;
1711 rqst.rq_iter_size = iov_iter_count(&wdata->iter);
1713 cifs_dbg(FYI, "async write at %llu %u bytes\n",
1714 wdata->offset, wdata->bytes);
1716 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
1717 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
1720 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
1721 put_bcc(wdata->bytes + 1, &smb->hdr);
1724 struct smb_com_writex_req *smbw =
1725 (struct smb_com_writex_req *)smb;
1726 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
1727 put_bcc(wdata->bytes + 5, &smbw->hdr);
1728 iov[1].iov_len += 4; /* pad bigger by four bytes */
1731 kref_get(&wdata->refcount);
1732 rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
1733 cifs_writev_callback, NULL, wdata, 0, NULL);
1736 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1738 kref_put(&wdata->refcount, release);
1741 cifs_small_buf_release(smb);
1746 CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
1747 unsigned int *nbytes, struct kvec *iov, int n_vec)
1750 WRITE_REQ *pSMB = NULL;
1753 int resp_buf_type = 0;
1754 __u32 pid = io_parms->pid;
1755 __u16 netfid = io_parms->netfid;
1756 __u64 offset = io_parms->offset;
1757 struct cifs_tcon *tcon = io_parms->tcon;
1758 unsigned int count = io_parms->length;
1759 struct kvec rsp_iov;
1763 cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count);
1765 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
1769 if ((offset >> 32) > 0) {
1770 /* can not handle big offset for old srv */
1774 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1778 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1779 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1781 /* tcon and ses pointer are checked in smb_init */
1782 if (tcon->ses->server == NULL)
1783 return -ECONNABORTED;
1785 pSMB->AndXCommand = 0xFF; /* none */
1787 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1789 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1790 pSMB->Reserved = 0xFFFFFFFF;
1791 pSMB->WriteMode = 0;
1792 pSMB->Remaining = 0;
1795 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1797 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1798 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1799 /* header + 1 byte pad */
1800 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
1802 inc_rfc1001_len(pSMB, count + 1);
1803 else /* wct == 12 */
1804 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
1806 pSMB->ByteCount = cpu_to_le16(count + 1);
1807 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1808 struct smb_com_writex_req *pSMBW =
1809 (struct smb_com_writex_req *)pSMB;
1810 pSMBW->ByteCount = cpu_to_le16(count + 5);
1812 iov[0].iov_base = pSMB;
1814 iov[0].iov_len = smb_hdr_len + 4;
1815 else /* wct == 12 pad bigger by four bytes */
1816 iov[0].iov_len = smb_hdr_len + 8;
1818 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0,
1820 cifs_small_buf_release(pSMB);
1821 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1823 cifs_dbg(FYI, "Send error Write2 = %d\n", rc);
1824 } else if (resp_buf_type == 0) {
1825 /* presumably this can not happen, but best to be safe */
1828 WRITE_RSP *pSMBr = (WRITE_RSP *)rsp_iov.iov_base;
1829 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1830 *nbytes = (*nbytes) << 16;
1831 *nbytes += le16_to_cpu(pSMBr->Count);
1834 * Mask off high 16 bits when bytes written as returned by the
1835 * server is greater than bytes requested by the client. OS/2
1836 * servers are known to set incorrect CountHigh values.
1838 if (*nbytes > count)
1842 free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
1844 /* Note: On -EAGAIN error only caller can retry on handle based calls
1845 since file handle passed in no longer valid */
1850 int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
1851 const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
1852 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
1855 LOCK_REQ *pSMB = NULL;
1857 struct kvec rsp_iov;
1861 cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n",
1862 num_lock, num_unlock);
1864 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1869 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
1870 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
1871 pSMB->LockType = lock_type;
1872 pSMB->AndXCommand = 0xFF; /* none */
1873 pSMB->Fid = netfid; /* netfid stays le */
1875 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
1876 inc_rfc1001_len(pSMB, count);
1877 pSMB->ByteCount = cpu_to_le16(count);
1879 iov[0].iov_base = (char *)pSMB;
1880 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
1881 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
1882 iov[1].iov_base = (char *)buf;
1883 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
1885 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
1886 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type,
1887 CIFS_NO_RSP_BUF, &rsp_iov);
1888 cifs_small_buf_release(pSMB);
1890 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc);
1896 CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
1897 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
1898 const __u64 offset, const __u32 numUnlock,
1899 const __u32 numLock, const __u8 lockType,
1900 const bool waitFlag, const __u8 oplock_level)
1903 LOCK_REQ *pSMB = NULL;
1904 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
1909 cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n",
1910 (int)waitFlag, numLock);
1911 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1916 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1917 /* no response expected */
1918 flags = CIFS_NO_SRV_RSP | CIFS_NON_BLOCKING | CIFS_OBREAK_OP;
1920 } else if (waitFlag) {
1921 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1922 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1927 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1928 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1929 pSMB->LockType = lockType;
1930 pSMB->OplockLevel = oplock_level;
1931 pSMB->AndXCommand = 0xFF; /* none */
1932 pSMB->Fid = smb_file_id; /* netfid stays le */
1934 if ((numLock != 0) || (numUnlock != 0)) {
1935 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
1936 /* BB where to store pid high? */
1937 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1938 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1939 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1940 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1941 count = sizeof(LOCKING_ANDX_RANGE);
1946 inc_rfc1001_len(pSMB, count);
1947 pSMB->ByteCount = cpu_to_le16(count);
1950 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1951 (struct smb_hdr *) pSMB, &bytes_returned);
1953 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
1954 cifs_small_buf_release(pSMB);
1955 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
1957 cifs_dbg(FYI, "Send error in Lock = %d\n", rc);
1959 /* Note: On -EAGAIN error only caller can retry on handle based calls
1960 since file handle passed in no longer valid */
1965 CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
1966 const __u16 smb_file_id, const __u32 netpid,
1967 const loff_t start_offset, const __u64 len,
1968 struct file_lock *pLockData, const __u16 lock_type,
1969 const bool waitFlag)
1971 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1972 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1973 struct cifs_posix_lock *parm_data;
1976 int bytes_returned = 0;
1977 int resp_buf_type = 0;
1978 __u16 params, param_offset, offset, byte_count, count;
1980 struct kvec rsp_iov;
1982 cifs_dbg(FYI, "Posix Lock\n");
1984 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1989 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1992 pSMB->MaxSetupCount = 0;
1995 pSMB->Reserved2 = 0;
1996 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1997 offset = param_offset + params;
1999 count = sizeof(struct cifs_posix_lock);
2000 pSMB->MaxParameterCount = cpu_to_le16(2);
2001 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2002 pSMB->SetupCount = 1;
2003 pSMB->Reserved3 = 0;
2005 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2007 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2008 byte_count = 3 /* pad */ + params + count;
2009 pSMB->DataCount = cpu_to_le16(count);
2010 pSMB->ParameterCount = cpu_to_le16(params);
2011 pSMB->TotalDataCount = pSMB->DataCount;
2012 pSMB->TotalParameterCount = pSMB->ParameterCount;
2013 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2014 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
2015 parm_data = (struct cifs_posix_lock *)
2016 (((char *)pSMB) + offset + 4);
2018 parm_data->lock_type = cpu_to_le16(lock_type);
2020 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2021 parm_data->lock_flags = cpu_to_le16(1);
2022 pSMB->Timeout = cpu_to_le32(-1);
2026 parm_data->pid = cpu_to_le32(netpid);
2027 parm_data->start = cpu_to_le64(start_offset);
2028 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
2030 pSMB->DataOffset = cpu_to_le16(offset);
2031 pSMB->Fid = smb_file_id;
2032 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2033 pSMB->Reserved4 = 0;
2034 inc_rfc1001_len(pSMB, byte_count);
2035 pSMB->ByteCount = cpu_to_le16(byte_count);
2037 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2038 (struct smb_hdr *) pSMBr, &bytes_returned);
2040 iov[0].iov_base = (char *)pSMB;
2041 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2042 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2043 &resp_buf_type, timeout, &rsp_iov);
2044 pSMBr = (struct smb_com_transaction2_sfi_rsp *)rsp_iov.iov_base;
2046 cifs_small_buf_release(pSMB);
2049 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc);
2050 } else if (pLockData) {
2051 /* lock structure can be returned on get */
2054 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2056 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2057 rc = -EIO; /* bad smb */
2060 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2061 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2062 if (data_count < sizeof(struct cifs_posix_lock)) {
2066 parm_data = (struct cifs_posix_lock *)
2067 ((char *)&pSMBr->hdr.Protocol + data_offset);
2068 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
2069 pLockData->fl_type = F_UNLCK;
2071 if (parm_data->lock_type ==
2072 cpu_to_le16(CIFS_RDLCK))
2073 pLockData->fl_type = F_RDLCK;
2074 else if (parm_data->lock_type ==
2075 cpu_to_le16(CIFS_WRLCK))
2076 pLockData->fl_type = F_WRLCK;
2078 pLockData->fl_start = le64_to_cpu(parm_data->start);
2079 pLockData->fl_end = pLockData->fl_start +
2080 (le64_to_cpu(parm_data->length) ?
2081 le64_to_cpu(parm_data->length) - 1 : 0);
2082 pLockData->fl_pid = -le32_to_cpu(parm_data->pid);
2087 free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
2089 /* Note: On -EAGAIN error only caller can retry on handle based calls
2090 since file handle passed in no longer valid */
2097 CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2100 CLOSE_REQ *pSMB = NULL;
2101 cifs_dbg(FYI, "In CIFSSMBClose\n");
2103 /* do not retry on dead session on close */
2104 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2110 pSMB->FileID = (__u16) smb_file_id;
2111 pSMB->LastWriteTime = 0xFFFFFFFF;
2112 pSMB->ByteCount = 0;
2113 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2114 cifs_small_buf_release(pSMB);
2115 cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
2118 /* EINTR is expected when user ctl-c to kill app */
2119 cifs_dbg(VFS, "Send error in Close = %d\n", rc);
2123 /* Since session is dead, file will be closed on server already */
2131 CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2134 FLUSH_REQ *pSMB = NULL;
2135 cifs_dbg(FYI, "In CIFSSMBFlush\n");
2137 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2141 pSMB->FileID = (__u16) smb_file_id;
2142 pSMB->ByteCount = 0;
2143 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2144 cifs_small_buf_release(pSMB);
2145 cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
2147 cifs_dbg(VFS, "Send error in Flush = %d\n", rc);
2152 int CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
2153 struct dentry *source_dentry,
2154 const char *from_name, const char *to_name,
2155 struct cifs_sb_info *cifs_sb)
2158 RENAME_REQ *pSMB = NULL;
2159 RENAME_RSP *pSMBr = NULL;
2161 int name_len, name_len2;
2163 int remap = cifs_remap(cifs_sb);
2165 cifs_dbg(FYI, "In CIFSSMBRename\n");
2167 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2172 pSMB->BufferFormat = 0x04;
2173 pSMB->SearchAttributes =
2174 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2177 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2178 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2179 from_name, PATH_MAX,
2180 cifs_sb->local_nls, remap);
2181 name_len++; /* trailing null */
2183 pSMB->OldFileName[name_len] = 0x04; /* pad */
2184 /* protocol requires ASCII signature byte on Unicode string */
2185 pSMB->OldFileName[name_len + 1] = 0x00;
2187 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2188 to_name, PATH_MAX, cifs_sb->local_nls,
2190 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2191 name_len2 *= 2; /* convert to bytes */
2193 name_len = copy_path_name(pSMB->OldFileName, from_name);
2194 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name);
2195 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2196 name_len2++; /* signature byte */
2199 count = 1 /* 1st signature byte */ + name_len + name_len2;
2200 inc_rfc1001_len(pSMB, count);
2201 pSMB->ByteCount = cpu_to_le16(count);
2203 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2204 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2205 cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
2207 cifs_dbg(FYI, "Send error in rename = %d\n", rc);
2209 cifs_buf_release(pSMB);
2217 int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
2218 int netfid, const char *target_name,
2219 const struct nls_table *nls_codepage, int remap)
2221 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2222 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2223 struct set_file_rename *rename_info;
2225 char dummy_string[30];
2227 int bytes_returned = 0;
2229 __u16 params, param_offset, offset, count, byte_count;
2231 cifs_dbg(FYI, "Rename to File by handle\n");
2232 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2238 pSMB->MaxSetupCount = 0;
2242 pSMB->Reserved2 = 0;
2243 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2244 offset = param_offset + params;
2246 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
2247 data_offset = (char *)(pSMB) + offset + 4;
2248 rename_info = (struct set_file_rename *) data_offset;
2249 pSMB->MaxParameterCount = cpu_to_le16(2);
2250 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2251 pSMB->SetupCount = 1;
2252 pSMB->Reserved3 = 0;
2253 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2254 byte_count = 3 /* pad */ + params;
2255 pSMB->ParameterCount = cpu_to_le16(params);
2256 pSMB->TotalParameterCount = pSMB->ParameterCount;
2257 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2258 pSMB->DataOffset = cpu_to_le16(offset);
2259 /* construct random name ".cifs_tmp<inodenum><mid>" */
2260 rename_info->overwrite = cpu_to_le32(1);
2261 rename_info->root_fid = 0;
2262 /* unicode only call */
2263 if (target_name == NULL) {
2264 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2266 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2267 dummy_string, 24, nls_codepage, remap);
2270 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2271 target_name, PATH_MAX, nls_codepage,
2274 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2275 count = sizeof(struct set_file_rename) + (2 * len_of_str);
2276 byte_count += count;
2277 pSMB->DataCount = cpu_to_le16(count);
2278 pSMB->TotalDataCount = pSMB->DataCount;
2280 pSMB->InformationLevel =
2281 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2282 pSMB->Reserved4 = 0;
2283 inc_rfc1001_len(pSMB, byte_count);
2284 pSMB->ByteCount = cpu_to_le16(byte_count);
2285 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2286 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2287 cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
2289 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n",
2292 cifs_buf_release(pSMB);
2294 /* Note: On -EAGAIN error only caller can retry on handle based calls
2295 since file handle passed in no longer valid */
2301 CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
2302 const char *fromName, const __u16 target_tid, const char *toName,
2303 const int flags, const struct nls_table *nls_codepage, int remap)
2306 COPY_REQ *pSMB = NULL;
2307 COPY_RSP *pSMBr = NULL;
2309 int name_len, name_len2;
2312 cifs_dbg(FYI, "In CIFSSMBCopy\n");
2314 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2319 pSMB->BufferFormat = 0x04;
2320 pSMB->Tid2 = target_tid;
2322 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2324 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2325 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2326 fromName, PATH_MAX, nls_codepage,
2328 name_len++; /* trailing null */
2330 pSMB->OldFileName[name_len] = 0x04; /* pad */
2331 /* protocol requires ASCII signature byte on Unicode string */
2332 pSMB->OldFileName[name_len + 1] = 0x00;
2334 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2335 toName, PATH_MAX, nls_codepage, remap);
2336 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2337 name_len2 *= 2; /* convert to bytes */
2339 name_len = copy_path_name(pSMB->OldFileName, fromName);
2340 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2341 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, toName);
2342 name_len2++; /* signature byte */
2345 count = 1 /* 1st signature byte */ + name_len + name_len2;
2346 inc_rfc1001_len(pSMB, count);
2347 pSMB->ByteCount = cpu_to_le16(count);
2349 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2350 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2352 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n",
2353 rc, le16_to_cpu(pSMBr->CopyCount));
2355 cifs_buf_release(pSMB);
2364 CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
2365 const char *fromName, const char *toName,
2366 const struct nls_table *nls_codepage, int remap)
2368 TRANSACTION2_SPI_REQ *pSMB = NULL;
2369 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2372 int name_len_target;
2374 int bytes_returned = 0;
2375 __u16 params, param_offset, offset, byte_count;
2377 cifs_dbg(FYI, "In Symlink Unix style\n");
2379 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2384 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2386 cifsConvertToUTF16((__le16 *) pSMB->FileName, fromName,
2387 /* find define for this maxpathcomponent */
2388 PATH_MAX, nls_codepage, remap);
2389 name_len++; /* trailing null */
2393 name_len = copy_path_name(pSMB->FileName, fromName);
2395 params = 6 + name_len;
2396 pSMB->MaxSetupCount = 0;
2400 pSMB->Reserved2 = 0;
2401 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2402 InformationLevel) - 4;
2403 offset = param_offset + params;
2405 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
2406 data_offset = (char *)pSMB + offset + 4;
2407 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2409 cifsConvertToUTF16((__le16 *) data_offset, toName,
2410 /* find define for this maxpathcomponent */
2411 PATH_MAX, nls_codepage, remap);
2412 name_len_target++; /* trailing null */
2413 name_len_target *= 2;
2415 name_len_target = copy_path_name(data_offset, toName);
2418 pSMB->MaxParameterCount = cpu_to_le16(2);
2419 /* BB find exact max on data count below from sess */
2420 pSMB->MaxDataCount = cpu_to_le16(1000);
2421 pSMB->SetupCount = 1;
2422 pSMB->Reserved3 = 0;
2423 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2424 byte_count = 3 /* pad */ + params + name_len_target;
2425 pSMB->DataCount = cpu_to_le16(name_len_target);
2426 pSMB->ParameterCount = cpu_to_le16(params);
2427 pSMB->TotalDataCount = pSMB->DataCount;
2428 pSMB->TotalParameterCount = pSMB->ParameterCount;
2429 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2430 pSMB->DataOffset = cpu_to_le16(offset);
2431 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2432 pSMB->Reserved4 = 0;
2433 inc_rfc1001_len(pSMB, byte_count);
2434 pSMB->ByteCount = cpu_to_le16(byte_count);
2435 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2436 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2437 cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
2439 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n",
2442 cifs_buf_release(pSMB);
2445 goto createSymLinkRetry;
2451 CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2452 const char *fromName, const char *toName,
2453 const struct nls_table *nls_codepage, int remap)
2455 TRANSACTION2_SPI_REQ *pSMB = NULL;
2456 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2459 int name_len_target;
2461 int bytes_returned = 0;
2462 __u16 params, param_offset, offset, byte_count;
2464 cifs_dbg(FYI, "In Create Hard link Unix style\n");
2465 createHardLinkRetry:
2466 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2471 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2472 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2473 PATH_MAX, nls_codepage, remap);
2474 name_len++; /* trailing null */
2478 name_len = copy_path_name(pSMB->FileName, toName);
2480 params = 6 + name_len;
2481 pSMB->MaxSetupCount = 0;
2485 pSMB->Reserved2 = 0;
2486 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2487 InformationLevel) - 4;
2488 offset = param_offset + params;
2490 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
2491 data_offset = (char *)pSMB + offset + 4;
2492 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2494 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2495 PATH_MAX, nls_codepage, remap);
2496 name_len_target++; /* trailing null */
2497 name_len_target *= 2;
2499 name_len_target = copy_path_name(data_offset, fromName);
2502 pSMB->MaxParameterCount = cpu_to_le16(2);
2503 /* BB find exact max on data count below from sess*/
2504 pSMB->MaxDataCount = cpu_to_le16(1000);
2505 pSMB->SetupCount = 1;
2506 pSMB->Reserved3 = 0;
2507 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2508 byte_count = 3 /* pad */ + params + name_len_target;
2509 pSMB->ParameterCount = cpu_to_le16(params);
2510 pSMB->TotalParameterCount = pSMB->ParameterCount;
2511 pSMB->DataCount = cpu_to_le16(name_len_target);
2512 pSMB->TotalDataCount = pSMB->DataCount;
2513 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2514 pSMB->DataOffset = cpu_to_le16(offset);
2515 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2516 pSMB->Reserved4 = 0;
2517 inc_rfc1001_len(pSMB, byte_count);
2518 pSMB->ByteCount = cpu_to_le16(byte_count);
2519 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2520 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2521 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2523 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n",
2526 cifs_buf_release(pSMB);
2528 goto createHardLinkRetry;
2533 int CIFSCreateHardLink(const unsigned int xid,
2534 struct cifs_tcon *tcon,
2535 struct dentry *source_dentry,
2536 const char *from_name, const char *to_name,
2537 struct cifs_sb_info *cifs_sb)
2540 NT_RENAME_REQ *pSMB = NULL;
2541 RENAME_RSP *pSMBr = NULL;
2543 int name_len, name_len2;
2545 int remap = cifs_remap(cifs_sb);
2547 cifs_dbg(FYI, "In CIFSCreateHardLink\n");
2548 winCreateHardLinkRetry:
2550 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2555 pSMB->SearchAttributes =
2556 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2558 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2559 pSMB->ClusterCount = 0;
2561 pSMB->BufferFormat = 0x04;
2563 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2565 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
2566 PATH_MAX, cifs_sb->local_nls, remap);
2567 name_len++; /* trailing null */
2570 /* protocol specifies ASCII buffer format (0x04) for unicode */
2571 pSMB->OldFileName[name_len] = 0x04;
2572 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
2574 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2575 to_name, PATH_MAX, cifs_sb->local_nls,
2577 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2578 name_len2 *= 2; /* convert to bytes */
2580 name_len = copy_path_name(pSMB->OldFileName, from_name);
2581 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2582 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name);
2583 name_len2++; /* signature byte */
2586 count = 1 /* string type byte */ + name_len + name_len2;
2587 inc_rfc1001_len(pSMB, count);
2588 pSMB->ByteCount = cpu_to_le16(count);
2590 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2591 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2592 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2594 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
2596 cifs_buf_release(pSMB);
2598 goto winCreateHardLinkRetry;
2604 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
2605 const unsigned char *searchName, char **symlinkinfo,
2606 const struct nls_table *nls_codepage, int remap)
2608 /* SMB_QUERY_FILE_UNIX_LINK */
2609 TRANSACTION2_QPI_REQ *pSMB = NULL;
2610 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2614 __u16 params, byte_count;
2617 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
2620 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2625 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2627 cifsConvertToUTF16((__le16 *) pSMB->FileName,
2628 searchName, PATH_MAX, nls_codepage,
2630 name_len++; /* trailing null */
2633 name_len = copy_path_name(pSMB->FileName, searchName);
2636 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2637 pSMB->TotalDataCount = 0;
2638 pSMB->MaxParameterCount = cpu_to_le16(2);
2639 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
2640 pSMB->MaxSetupCount = 0;
2644 pSMB->Reserved2 = 0;
2645 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2646 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2647 pSMB->DataCount = 0;
2648 pSMB->DataOffset = 0;
2649 pSMB->SetupCount = 1;
2650 pSMB->Reserved3 = 0;
2651 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2652 byte_count = params + 1 /* pad */ ;
2653 pSMB->TotalParameterCount = cpu_to_le16(params);
2654 pSMB->ParameterCount = pSMB->TotalParameterCount;
2655 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2656 pSMB->Reserved4 = 0;
2657 inc_rfc1001_len(pSMB, byte_count);
2658 pSMB->ByteCount = cpu_to_le16(byte_count);
2660 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2661 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2663 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
2665 /* decode response */
2667 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2668 /* BB also check enough total bytes returned */
2669 if (rc || get_bcc(&pSMBr->hdr) < 2)
2673 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2675 data_start = ((char *) &pSMBr->hdr.Protocol) +
2676 le16_to_cpu(pSMBr->t2.DataOffset);
2678 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2683 /* BB FIXME investigate remapping reserved chars here */
2684 *symlinkinfo = cifs_strndup_from_utf16(data_start,
2685 count, is_unicode, nls_codepage);
2690 cifs_buf_release(pSMB);
2692 goto querySymLinkRetry;
2696 int cifs_query_reparse_point(const unsigned int xid,
2697 struct cifs_tcon *tcon,
2698 struct cifs_sb_info *cifs_sb,
2699 const char *full_path,
2700 u32 *tag, struct kvec *rsp,
2703 struct reparse_data_buffer *buf;
2704 struct cifs_open_parms oparms;
2705 TRANSACT_IOCTL_REQ *io_req = NULL;
2706 TRANSACT_IOCTL_RSP *io_rsp = NULL;
2707 struct cifs_fid fid;
2708 __u32 data_offset, data_count, len;
2714 cifs_tcon_dbg(FYI, "%s: path=%s\n", __func__, full_path);
2716 if (cap_unix(tcon->ses))
2719 oparms = (struct cifs_open_parms) {
2722 .desired_access = FILE_READ_ATTRIBUTES,
2723 .create_options = cifs_create_options(cifs_sb,
2724 OPEN_REPARSE_POINT),
2725 .disposition = FILE_OPEN,
2730 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2734 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon,
2735 (void **)&io_req, (void **)&io_rsp);
2739 io_req->TotalParameterCount = 0;
2740 io_req->TotalDataCount = 0;
2741 io_req->MaxParameterCount = cpu_to_le32(2);
2742 /* BB find exact data count max from sess structure BB */
2743 io_req->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
2744 io_req->MaxSetupCount = 4;
2745 io_req->Reserved = 0;
2746 io_req->ParameterOffset = 0;
2747 io_req->DataCount = 0;
2748 io_req->DataOffset = 0;
2749 io_req->SetupCount = 4;
2750 io_req->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2751 io_req->ParameterCount = io_req->TotalParameterCount;
2752 io_req->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2753 io_req->IsFsctl = 1;
2754 io_req->IsRootFlag = 0;
2755 io_req->Fid = fid.netfid;
2756 io_req->ByteCount = 0;
2758 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)io_req,
2759 (struct smb_hdr *)io_rsp, &io_rsp_len, 0);
2763 data_offset = le32_to_cpu(io_rsp->DataOffset);
2764 data_count = le32_to_cpu(io_rsp->DataCount);
2765 if (get_bcc(&io_rsp->hdr) < 2 || data_offset > 512 ||
2766 !data_count || data_count > 2048) {
2771 end = 2 + get_bcc(&io_rsp->hdr) + (__u8 *)&io_rsp->ByteCount;
2772 start = (__u8 *)&io_rsp->hdr.Protocol + data_offset;
2778 data_count = le16_to_cpu(io_rsp->ByteCount);
2779 buf = (struct reparse_data_buffer *)start;
2781 if (data_count < len ||
2782 data_count < le16_to_cpu(buf->ReparseDataLength) + len) {
2787 *tag = le32_to_cpu(buf->ReparseTag);
2788 rsp->iov_base = io_rsp;
2789 rsp->iov_len = io_rsp_len;
2790 *rsp_buftype = CIFS_LARGE_BUFFER;
2791 CIFSSMBClose(xid, tcon, fid.netfid);
2795 cifs_buf_release(io_req);
2796 CIFSSMBClose(xid, tcon, fid.netfid);
2801 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
2806 struct smb_com_transaction_compr_ioctl_req *pSMB;
2807 struct smb_com_transaction_ioctl_rsp *pSMBr;
2809 cifs_dbg(FYI, "Set compression for %u\n", fid);
2810 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2815 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT);
2817 pSMB->TotalParameterCount = 0;
2818 pSMB->TotalDataCount = cpu_to_le32(2);
2819 pSMB->MaxParameterCount = 0;
2820 pSMB->MaxDataCount = 0;
2821 pSMB->MaxSetupCount = 4;
2823 pSMB->ParameterOffset = 0;
2824 pSMB->DataCount = cpu_to_le32(2);
2826 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req,
2827 compression_state) - 4); /* 84 */
2828 pSMB->SetupCount = 4;
2829 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2830 pSMB->ParameterCount = 0;
2831 pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION);
2832 pSMB->IsFsctl = 1; /* FSCTL */
2833 pSMB->IsRootFlag = 0;
2834 pSMB->Fid = fid; /* file handle always le */
2835 /* 3 byte pad, followed by 2 byte compress state */
2836 pSMB->ByteCount = cpu_to_le16(5);
2837 inc_rfc1001_len(pSMB, 5);
2839 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2840 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2842 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc);
2844 cifs_buf_release(pSMB);
2847 * Note: On -EAGAIN error only caller can retry on handle based calls
2848 * since file handle passed in no longer valid.
2854 #ifdef CONFIG_CIFS_POSIX
2856 #ifdef CONFIG_FS_POSIX_ACL
2858 * cifs_init_posix_acl - convert ACL from cifs to POSIX ACL format
2859 * @ace: POSIX ACL entry to store converted ACL into
2860 * @cifs_ace: ACL in cifs format
2862 * Convert an Access Control Entry from wire format to local POSIX xattr
2865 * Note that the @cifs_uid member is used to store both {g,u}id_t.
2867 static void cifs_init_posix_acl(struct posix_acl_entry *ace,
2868 struct cifs_posix_ace *cifs_ace)
2870 /* u8 cifs fields do not need le conversion */
2871 ace->e_perm = cifs_ace->cifs_e_perm;
2872 ace->e_tag = cifs_ace->cifs_e_tag;
2874 switch (ace->e_tag) {
2876 ace->e_uid = make_kuid(&init_user_ns,
2877 le64_to_cpu(cifs_ace->cifs_uid));
2880 ace->e_gid = make_kgid(&init_user_ns,
2881 le64_to_cpu(cifs_ace->cifs_uid));
2888 * cifs_to_posix_acl - copy cifs ACL format to POSIX ACL format
2889 * @acl: ACLs returned in POSIX ACL format
2890 * @src: ACLs in cifs format
2891 * @acl_type: type of POSIX ACL requested
2892 * @size_of_data_area: size of SMB we got
2894 * This function converts ACLs from cifs format to POSIX ACL format.
2895 * If @acl is NULL then the size of the buffer required to store POSIX ACLs in
2896 * their uapi format is returned.
2898 static int cifs_to_posix_acl(struct posix_acl **acl, char *src,
2899 const int acl_type, const int size_of_data_area)
2903 struct cifs_posix_ace *pACE;
2904 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
2905 struct posix_acl *kacl = NULL;
2906 struct posix_acl_entry *pa, *pe;
2908 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2911 if (acl_type == ACL_TYPE_ACCESS) {
2912 count = le16_to_cpu(cifs_acl->access_entry_count);
2913 pACE = &cifs_acl->ace_array[0];
2914 size = sizeof(struct cifs_posix_acl);
2915 size += sizeof(struct cifs_posix_ace) * count;
2916 /* check if we would go beyond end of SMB */
2917 if (size_of_data_area < size) {
2918 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
2919 size_of_data_area, size);
2922 } else if (acl_type == ACL_TYPE_DEFAULT) {
2923 count = le16_to_cpu(cifs_acl->access_entry_count);
2924 size = sizeof(struct cifs_posix_acl);
2925 size += sizeof(struct cifs_posix_ace) * count;
2926 /* skip past access ACEs to get to default ACEs */
2927 pACE = &cifs_acl->ace_array[count];
2928 count = le16_to_cpu(cifs_acl->default_entry_count);
2929 size += sizeof(struct cifs_posix_ace) * count;
2930 /* check if we would go beyond end of SMB */
2931 if (size_of_data_area < size)
2938 /* Allocate number of POSIX ACLs to store in VFS format. */
2939 kacl = posix_acl_alloc(count, GFP_NOFS);
2943 FOREACH_ACL_ENTRY(pa, kacl, pe) {
2944 cifs_init_posix_acl(pa, pACE);
2953 * cifs_init_ace - convert ACL entry from POSIX ACL to cifs format
2954 * @cifs_ace: the cifs ACL entry to store into
2955 * @local_ace: the POSIX ACL entry to convert
2957 static void cifs_init_ace(struct cifs_posix_ace *cifs_ace,
2958 const struct posix_acl_entry *local_ace)
2960 cifs_ace->cifs_e_perm = local_ace->e_perm;
2961 cifs_ace->cifs_e_tag = local_ace->e_tag;
2963 switch (local_ace->e_tag) {
2965 cifs_ace->cifs_uid =
2966 cpu_to_le64(from_kuid(&init_user_ns, local_ace->e_uid));
2969 cifs_ace->cifs_uid =
2970 cpu_to_le64(from_kgid(&init_user_ns, local_ace->e_gid));
2973 cifs_ace->cifs_uid = cpu_to_le64(-1);
2978 * posix_acl_to_cifs - convert ACLs from POSIX ACL to cifs format
2979 * @parm_data: ACLs in cifs format to conver to
2980 * @acl: ACLs in POSIX ACL format to convert from
2981 * @acl_type: the type of POSIX ACLs stored in @acl
2983 * Return: the number cifs ACL entries after conversion
2985 static __u16 posix_acl_to_cifs(char *parm_data, const struct posix_acl *acl,
2989 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
2990 const struct posix_acl_entry *pa, *pe;
2994 if ((acl == NULL) || (cifs_acl == NULL))
2997 count = acl->a_count;
2998 cifs_dbg(FYI, "setting acl with %d entries\n", count);
3001 * Note that the uapi POSIX ACL version is verified by the VFS and is
3002 * independent of the cifs ACL version. Changing the POSIX ACL version
3003 * is a uapi change and if it's changed we will pass down the POSIX ACL
3004 * version in struct posix_acl from the VFS. For now there's really
3005 * only one that all filesystems know how to deal with.
3007 cifs_acl->version = cpu_to_le16(1);
3008 if (acl_type == ACL_TYPE_ACCESS) {
3009 cifs_acl->access_entry_count = cpu_to_le16(count);
3010 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF);
3011 } else if (acl_type == ACL_TYPE_DEFAULT) {
3012 cifs_acl->default_entry_count = cpu_to_le16(count);
3013 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF);
3015 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
3018 FOREACH_ACL_ENTRY(pa, acl, pe) {
3019 cifs_init_ace(&cifs_acl->ace_array[i++], pa);
3022 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3023 rc += sizeof(struct cifs_posix_acl);
3024 /* BB add check to make sure ACL does not overflow SMB */
3029 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon,
3030 const unsigned char *searchName, struct posix_acl **acl,
3031 const int acl_type, const struct nls_table *nls_codepage,
3034 /* SMB_QUERY_POSIX_ACL */
3035 TRANSACTION2_QPI_REQ *pSMB = NULL;
3036 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3040 __u16 params, byte_count;
3042 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
3045 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3050 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3052 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3053 searchName, PATH_MAX, nls_codepage,
3055 name_len++; /* trailing null */
3057 pSMB->FileName[name_len] = 0;
3058 pSMB->FileName[name_len+1] = 0;
3060 name_len = copy_path_name(pSMB->FileName, searchName);
3063 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3064 pSMB->TotalDataCount = 0;
3065 pSMB->MaxParameterCount = cpu_to_le16(2);
3066 /* BB find exact max data count below from sess structure BB */
3067 pSMB->MaxDataCount = cpu_to_le16(4000);
3068 pSMB->MaxSetupCount = 0;
3072 pSMB->Reserved2 = 0;
3073 pSMB->ParameterOffset = cpu_to_le16(
3074 offsetof(struct smb_com_transaction2_qpi_req,
3075 InformationLevel) - 4);
3076 pSMB->DataCount = 0;
3077 pSMB->DataOffset = 0;
3078 pSMB->SetupCount = 1;
3079 pSMB->Reserved3 = 0;
3080 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3081 byte_count = params + 1 /* pad */ ;
3082 pSMB->TotalParameterCount = cpu_to_le16(params);
3083 pSMB->ParameterCount = pSMB->TotalParameterCount;
3084 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3085 pSMB->Reserved4 = 0;
3086 inc_rfc1001_len(pSMB, byte_count);
3087 pSMB->ByteCount = cpu_to_le16(byte_count);
3089 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3090 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3091 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3093 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
3095 /* decode response */
3097 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3098 /* BB also check enough total bytes returned */
3099 if (rc || get_bcc(&pSMBr->hdr) < 2)
3100 rc = -EIO; /* bad smb */
3102 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3103 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3104 rc = cifs_to_posix_acl(acl,
3105 (char *)&pSMBr->hdr.Protocol+data_offset,
3109 cifs_buf_release(pSMB);
3111 * The else branch after SendReceive() doesn't return EAGAIN so if we
3112 * allocated @acl in cifs_to_posix_acl() we are guaranteed to return
3113 * here and don't leak POSIX ACLs.
3120 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
3121 const unsigned char *fileName, const struct posix_acl *acl,
3122 const int acl_type, const struct nls_table *nls_codepage,
3125 struct smb_com_transaction2_spi_req *pSMB = NULL;
3126 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3130 int bytes_returned = 0;
3131 __u16 params, byte_count, data_count, param_offset, offset;
3133 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
3135 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3139 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3141 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3142 PATH_MAX, nls_codepage, remap);
3143 name_len++; /* trailing null */
3146 name_len = copy_path_name(pSMB->FileName, fileName);
3148 params = 6 + name_len;
3149 pSMB->MaxParameterCount = cpu_to_le16(2);
3150 /* BB find max SMB size from sess */
3151 pSMB->MaxDataCount = cpu_to_le16(1000);
3152 pSMB->MaxSetupCount = 0;
3156 pSMB->Reserved2 = 0;
3157 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3158 InformationLevel) - 4;
3159 offset = param_offset + params;
3160 parm_data = ((char *)pSMB) + sizeof(pSMB->hdr.smb_buf_length) + offset;
3161 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3163 /* convert to on the wire format for POSIX ACL */
3164 data_count = posix_acl_to_cifs(parm_data, acl, acl_type);
3166 if (data_count == 0) {
3168 goto setACLerrorExit;
3170 pSMB->DataOffset = cpu_to_le16(offset);
3171 pSMB->SetupCount = 1;
3172 pSMB->Reserved3 = 0;
3173 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3174 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3175 byte_count = 3 /* pad */ + params + data_count;
3176 pSMB->DataCount = cpu_to_le16(data_count);
3177 pSMB->TotalDataCount = pSMB->DataCount;
3178 pSMB->ParameterCount = cpu_to_le16(params);
3179 pSMB->TotalParameterCount = pSMB->ParameterCount;
3180 pSMB->Reserved4 = 0;
3181 inc_rfc1001_len(pSMB, byte_count);
3182 pSMB->ByteCount = cpu_to_le16(byte_count);
3183 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3184 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3186 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
3189 cifs_buf_release(pSMB);
3195 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon,
3196 const unsigned char *searchName, struct posix_acl **acl,
3197 const int acl_type, const struct nls_table *nls_codepage,
3203 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
3204 const unsigned char *fileName, const struct posix_acl *acl,
3205 const int acl_type, const struct nls_table *nls_codepage,
3210 #endif /* CONFIG_FS_POSIX_ACL */
3213 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
3214 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3217 struct smb_t2_qfi_req *pSMB = NULL;
3218 struct smb_t2_qfi_rsp *pSMBr = NULL;
3220 __u16 params, byte_count;
3222 cifs_dbg(FYI, "In GetExtAttr\n");
3227 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3232 params = 2 /* level */ + 2 /* fid */;
3233 pSMB->t2.TotalDataCount = 0;
3234 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3235 /* BB find exact max data count below from sess structure BB */
3236 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3237 pSMB->t2.MaxSetupCount = 0;
3238 pSMB->t2.Reserved = 0;
3240 pSMB->t2.Timeout = 0;
3241 pSMB->t2.Reserved2 = 0;
3242 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3244 pSMB->t2.DataCount = 0;
3245 pSMB->t2.DataOffset = 0;
3246 pSMB->t2.SetupCount = 1;
3247 pSMB->t2.Reserved3 = 0;
3248 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3249 byte_count = params + 1 /* pad */ ;
3250 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3251 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3252 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3255 inc_rfc1001_len(pSMB, byte_count);
3256 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3258 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3259 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3261 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
3263 /* decode response */
3264 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3265 /* BB also check enough total bytes returned */
3266 if (rc || get_bcc(&pSMBr->hdr) < 2)
3267 /* If rc should we check for EOPNOSUPP and
3268 disable the srvino flag? or in caller? */
3269 rc = -EIO; /* bad smb */
3271 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3272 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3273 struct file_chattr_info *pfinfo;
3276 cifs_dbg(FYI, "Invalid size ret in GetExtAttr\n");
3280 pfinfo = (struct file_chattr_info *)
3281 (data_offset + (char *) &pSMBr->hdr.Protocol);
3282 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3283 *pMask = le64_to_cpu(pfinfo->mask);
3287 cifs_buf_release(pSMB);
3289 goto GetExtAttrRetry;
3293 #endif /* CONFIG_POSIX */
3296 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3297 * all NT TRANSACTS that we init here have total parm and data under about 400
3298 * bytes (to fit in small cifs buffer size), which is the case so far, it
3299 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3300 * returned setup area) and MaxParameterCount (returned parms size) must be set
3304 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3305 const int parm_len, struct cifs_tcon *tcon,
3310 struct smb_com_ntransact_req *pSMB;
3312 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3316 *ret_buf = (void *)pSMB;
3318 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3319 pSMB->TotalDataCount = 0;
3320 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3321 pSMB->ParameterCount = pSMB->TotalParameterCount;
3322 pSMB->DataCount = pSMB->TotalDataCount;
3323 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3324 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3325 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3326 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3327 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3328 pSMB->SubCommand = cpu_to_le16(sub_command);
3333 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3334 __u32 *pparmlen, __u32 *pdatalen)
3337 __u32 data_count, data_offset, parm_count, parm_offset;
3338 struct smb_com_ntransact_rsp *pSMBr;
3347 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3349 bcc = get_bcc(&pSMBr->hdr);
3350 end_of_smb = 2 /* sizeof byte count */ + bcc +
3351 (char *)&pSMBr->ByteCount;
3353 data_offset = le32_to_cpu(pSMBr->DataOffset);
3354 data_count = le32_to_cpu(pSMBr->DataCount);
3355 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3356 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3358 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3359 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3361 /* should we also check that parm and data areas do not overlap? */
3362 if (*ppparm > end_of_smb) {
3363 cifs_dbg(FYI, "parms start after end of smb\n");
3365 } else if (parm_count + *ppparm > end_of_smb) {
3366 cifs_dbg(FYI, "parm end after end of smb\n");
3368 } else if (*ppdata > end_of_smb) {
3369 cifs_dbg(FYI, "data starts after end of smb\n");
3371 } else if (data_count + *ppdata > end_of_smb) {
3372 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3373 *ppdata, data_count, (data_count + *ppdata),
3376 } else if (parm_count + data_count > bcc) {
3377 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
3380 *pdatalen = data_count;
3381 *pparmlen = parm_count;
3385 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3387 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3388 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3392 QUERY_SEC_DESC_REQ *pSMB;
3394 struct kvec rsp_iov;
3396 cifs_dbg(FYI, "GetCifsACL\n");
3401 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3402 8 /* parm len */, tcon, (void **) &pSMB);
3406 pSMB->MaxParameterCount = cpu_to_le32(4);
3407 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3408 pSMB->MaxSetupCount = 0;
3409 pSMB->Fid = fid; /* file handle always le */
3410 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3412 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3413 inc_rfc1001_len(pSMB, 11);
3414 iov[0].iov_base = (char *)pSMB;
3415 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3417 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3419 cifs_small_buf_release(pSMB);
3420 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3422 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
3423 } else { /* decode response */
3427 struct smb_com_ntransact_rsp *pSMBr;
3430 /* validate_nttransact */
3431 rc = validate_ntransact(rsp_iov.iov_base, (char **)&parm,
3432 &pdata, &parm_len, pbuflen);
3435 pSMBr = (struct smb_com_ntransact_rsp *)rsp_iov.iov_base;
3437 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3438 pSMBr, parm, *acl_inf);
3440 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3441 rc = -EIO; /* bad smb */
3446 /* BB check that data area is minimum length and as big as acl_len */
3448 acl_len = le32_to_cpu(*parm);
3449 if (acl_len != *pbuflen) {
3450 cifs_dbg(VFS, "acl length %d does not match %d\n",
3452 if (*pbuflen > acl_len)
3456 /* check if buffer is big enough for the acl
3457 header followed by the smallest SID */
3458 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3459 (*pbuflen >= 64 * 1024)) {
3460 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
3464 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
3465 if (*acl_inf == NULL) {
3472 free_rsp_buf(buf_type, rsp_iov.iov_base);
3477 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3478 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3480 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3482 int bytes_returned = 0;
3483 SET_SEC_DESC_REQ *pSMB = NULL;
3487 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
3491 pSMB->MaxSetupCount = 0;
3495 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3496 data_count = acllen;
3497 data_offset = param_offset + param_count;
3498 byte_count = 3 /* pad */ + param_count;
3500 pSMB->DataCount = cpu_to_le32(data_count);
3501 pSMB->TotalDataCount = pSMB->DataCount;
3502 pSMB->MaxParameterCount = cpu_to_le32(4);
3503 pSMB->MaxDataCount = cpu_to_le32(16384);
3504 pSMB->ParameterCount = cpu_to_le32(param_count);
3505 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3506 pSMB->TotalParameterCount = pSMB->ParameterCount;
3507 pSMB->DataOffset = cpu_to_le32(data_offset);
3508 pSMB->SetupCount = 0;
3509 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3510 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3512 pSMB->Fid = fid; /* file handle always le */
3513 pSMB->Reserved2 = 0;
3514 pSMB->AclFlags = cpu_to_le32(aclflag);
3516 if (pntsd && acllen) {
3517 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
3518 data_offset, pntsd, acllen);
3519 inc_rfc1001_len(pSMB, byte_count + data_count);
3521 inc_rfc1001_len(pSMB, byte_count);
3523 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3524 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3526 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3527 bytes_returned, rc);
3529 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
3530 cifs_buf_release(pSMB);
3533 goto setCifsAclRetry;
3539 /* Legacy Query Path Information call for lookup to old servers such
3542 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
3543 const char *search_name, FILE_ALL_INFO *data,
3544 const struct nls_table *nls_codepage, int remap)
3546 QUERY_INFORMATION_REQ *pSMB;
3547 QUERY_INFORMATION_RSP *pSMBr;
3552 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
3554 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3559 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3561 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3562 search_name, PATH_MAX, nls_codepage,
3564 name_len++; /* trailing null */
3567 name_len = copy_path_name(pSMB->FileName, search_name);
3569 pSMB->BufferFormat = 0x04;
3570 name_len++; /* account for buffer type byte */
3571 inc_rfc1001_len(pSMB, (__u16)name_len);
3572 pSMB->ByteCount = cpu_to_le16(name_len);
3574 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3575 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3577 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
3579 struct timespec64 ts;
3580 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3582 /* decode response */
3583 /* BB FIXME - add time zone adjustment BB */
3584 memset(data, 0, sizeof(FILE_ALL_INFO));
3587 /* decode time fields */
3588 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3589 data->LastWriteTime = data->ChangeTime;
3590 data->LastAccessTime = 0;
3591 data->AllocationSize =
3592 cpu_to_le64(le32_to_cpu(pSMBr->size));
3593 data->EndOfFile = data->AllocationSize;
3595 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3597 rc = -EIO; /* bad buffer passed in */
3599 cifs_buf_release(pSMB);
3608 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
3609 u16 netfid, FILE_ALL_INFO *pFindData)
3611 struct smb_t2_qfi_req *pSMB = NULL;
3612 struct smb_t2_qfi_rsp *pSMBr = NULL;
3615 __u16 params, byte_count;
3618 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3623 params = 2 /* level */ + 2 /* fid */;
3624 pSMB->t2.TotalDataCount = 0;
3625 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3626 /* BB find exact max data count below from sess structure BB */
3627 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3628 pSMB->t2.MaxSetupCount = 0;
3629 pSMB->t2.Reserved = 0;
3631 pSMB->t2.Timeout = 0;
3632 pSMB->t2.Reserved2 = 0;
3633 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3635 pSMB->t2.DataCount = 0;
3636 pSMB->t2.DataOffset = 0;
3637 pSMB->t2.SetupCount = 1;
3638 pSMB->t2.Reserved3 = 0;
3639 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3640 byte_count = params + 1 /* pad */ ;
3641 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3642 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3643 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3646 inc_rfc1001_len(pSMB, byte_count);
3647 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3649 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3650 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3652 cifs_dbg(FYI, "Send error in QFileInfo = %d\n", rc);
3653 } else { /* decode response */
3654 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3656 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3658 else if (get_bcc(&pSMBr->hdr) < 40)
3659 rc = -EIO; /* bad smb */
3660 else if (pFindData) {
3661 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3662 memcpy((char *) pFindData,
3663 (char *) &pSMBr->hdr.Protocol +
3664 data_offset, sizeof(FILE_ALL_INFO));
3668 cifs_buf_release(pSMB);
3670 goto QFileInfoRetry;
3676 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
3677 const char *search_name, FILE_ALL_INFO *data,
3678 int legacy /* old style infolevel */,
3679 const struct nls_table *nls_codepage, int remap)
3681 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3682 TRANSACTION2_QPI_REQ *pSMB = NULL;
3683 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3687 __u16 params, byte_count;
3689 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
3691 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3696 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3698 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
3699 PATH_MAX, nls_codepage, remap);
3700 name_len++; /* trailing null */
3703 name_len = copy_path_name(pSMB->FileName, search_name);
3706 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3707 pSMB->TotalDataCount = 0;
3708 pSMB->MaxParameterCount = cpu_to_le16(2);
3709 /* BB find exact max SMB PDU from sess structure BB */
3710 pSMB->MaxDataCount = cpu_to_le16(4000);
3711 pSMB->MaxSetupCount = 0;
3715 pSMB->Reserved2 = 0;
3716 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3717 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3718 pSMB->DataCount = 0;
3719 pSMB->DataOffset = 0;
3720 pSMB->SetupCount = 1;
3721 pSMB->Reserved3 = 0;
3722 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3723 byte_count = params + 1 /* pad */ ;
3724 pSMB->TotalParameterCount = cpu_to_le16(params);
3725 pSMB->ParameterCount = pSMB->TotalParameterCount;
3727 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3729 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3730 pSMB->Reserved4 = 0;
3731 inc_rfc1001_len(pSMB, byte_count);
3732 pSMB->ByteCount = cpu_to_le16(byte_count);
3734 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3735 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3737 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
3738 } else { /* decode response */
3739 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3741 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3743 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
3744 rc = -EIO; /* bad smb */
3745 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
3746 rc = -EIO; /* 24 or 26 expected but we do not read
3750 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3753 * On legacy responses we do not read the last field,
3754 * EAsize, fortunately since it varies by subdialect and
3755 * also note it differs on Set vs Get, ie two bytes or 4
3756 * bytes depending but we don't care here.
3759 size = sizeof(FILE_INFO_STANDARD);
3761 size = sizeof(FILE_ALL_INFO);
3762 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
3767 cifs_buf_release(pSMB);
3769 goto QPathInfoRetry;
3775 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
3776 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
3778 struct smb_t2_qfi_req *pSMB = NULL;
3779 struct smb_t2_qfi_rsp *pSMBr = NULL;
3782 __u16 params, byte_count;
3785 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3790 params = 2 /* level */ + 2 /* fid */;
3791 pSMB->t2.TotalDataCount = 0;
3792 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3793 /* BB find exact max data count below from sess structure BB */
3794 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3795 pSMB->t2.MaxSetupCount = 0;
3796 pSMB->t2.Reserved = 0;
3798 pSMB->t2.Timeout = 0;
3799 pSMB->t2.Reserved2 = 0;
3800 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3802 pSMB->t2.DataCount = 0;
3803 pSMB->t2.DataOffset = 0;
3804 pSMB->t2.SetupCount = 1;
3805 pSMB->t2.Reserved3 = 0;
3806 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3807 byte_count = params + 1 /* pad */ ;
3808 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3809 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3810 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3813 inc_rfc1001_len(pSMB, byte_count);
3814 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3816 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3817 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3819 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d\n", rc);
3820 } else { /* decode response */
3821 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3823 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
3824 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
3825 rc = -EIO; /* bad smb */
3827 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3828 memcpy((char *) pFindData,
3829 (char *) &pSMBr->hdr.Protocol +
3831 sizeof(FILE_UNIX_BASIC_INFO));
3835 cifs_buf_release(pSMB);
3837 goto UnixQFileInfoRetry;
3843 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
3844 const unsigned char *searchName,
3845 FILE_UNIX_BASIC_INFO *pFindData,
3846 const struct nls_table *nls_codepage, int remap)
3848 /* SMB_QUERY_FILE_UNIX_BASIC */
3849 TRANSACTION2_QPI_REQ *pSMB = NULL;
3850 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3852 int bytes_returned = 0;
3854 __u16 params, byte_count;
3856 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
3858 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3863 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3865 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
3866 PATH_MAX, nls_codepage, remap);
3867 name_len++; /* trailing null */
3870 name_len = copy_path_name(pSMB->FileName, searchName);
3873 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3874 pSMB->TotalDataCount = 0;
3875 pSMB->MaxParameterCount = cpu_to_le16(2);
3876 /* BB find exact max SMB PDU from sess structure BB */
3877 pSMB->MaxDataCount = cpu_to_le16(4000);
3878 pSMB->MaxSetupCount = 0;
3882 pSMB->Reserved2 = 0;
3883 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3884 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3885 pSMB->DataCount = 0;
3886 pSMB->DataOffset = 0;
3887 pSMB->SetupCount = 1;
3888 pSMB->Reserved3 = 0;
3889 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3890 byte_count = params + 1 /* pad */ ;
3891 pSMB->TotalParameterCount = cpu_to_le16(params);
3892 pSMB->ParameterCount = pSMB->TotalParameterCount;
3893 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3894 pSMB->Reserved4 = 0;
3895 inc_rfc1001_len(pSMB, byte_count);
3896 pSMB->ByteCount = cpu_to_le16(byte_count);
3898 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3899 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3901 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d\n", rc);
3902 } else { /* decode response */
3903 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3905 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
3906 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
3907 rc = -EIO; /* bad smb */
3909 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3910 memcpy((char *) pFindData,
3911 (char *) &pSMBr->hdr.Protocol +
3913 sizeof(FILE_UNIX_BASIC_INFO));
3916 cifs_buf_release(pSMB);
3918 goto UnixQPathInfoRetry;
3923 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3925 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
3926 const char *searchName, struct cifs_sb_info *cifs_sb,
3927 __u16 *pnetfid, __u16 search_flags,
3928 struct cifs_search_info *psrch_inf, bool msearch)
3930 /* level 257 SMB_ */
3931 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3932 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3933 T2_FFIRST_RSP_PARMS *parms;
3934 struct nls_table *nls_codepage;
3936 __u16 params, byte_count;
3937 int bytes_returned = 0;
3938 int name_len, remap;
3941 cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
3944 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3949 nls_codepage = cifs_sb->local_nls;
3950 remap = cifs_remap(cifs_sb);
3952 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3954 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
3955 PATH_MAX, nls_codepage, remap);
3956 /* We can not add the asterik earlier in case
3957 it got remapped to 0xF03A as if it were part of the
3958 directory name instead of a wildcard */
3961 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
3962 pSMB->FileName[name_len+1] = 0;
3963 pSMB->FileName[name_len+2] = '*';
3964 pSMB->FileName[name_len+3] = 0;
3965 name_len += 4; /* now the trailing null */
3966 /* null terminate just in case */
3967 pSMB->FileName[name_len] = 0;
3968 pSMB->FileName[name_len+1] = 0;
3972 name_len = copy_path_name(pSMB->FileName, searchName);
3974 if (WARN_ON_ONCE(name_len > PATH_MAX-2))
3975 name_len = PATH_MAX-2;
3976 /* overwrite nul byte */
3977 pSMB->FileName[name_len-1] = CIFS_DIR_SEP(cifs_sb);
3978 pSMB->FileName[name_len] = '*';
3979 pSMB->FileName[name_len+1] = 0;
3984 params = 12 + name_len /* includes null */ ;
3985 pSMB->TotalDataCount = 0; /* no EAs */
3986 pSMB->MaxParameterCount = cpu_to_le16(10);
3987 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
3988 pSMB->MaxSetupCount = 0;
3992 pSMB->Reserved2 = 0;
3993 byte_count = params + 1 /* pad */ ;
3994 pSMB->TotalParameterCount = cpu_to_le16(params);
3995 pSMB->ParameterCount = pSMB->TotalParameterCount;
3996 pSMB->ParameterOffset = cpu_to_le16(
3997 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3999 pSMB->DataCount = 0;
4000 pSMB->DataOffset = 0;
4001 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4002 pSMB->Reserved3 = 0;
4003 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4004 pSMB->SearchAttributes =
4005 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4007 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4008 pSMB->SearchFlags = cpu_to_le16(search_flags);
4009 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4011 /* BB what should we set StorageType to? Does it matter? BB */
4012 pSMB->SearchStorageType = 0;
4013 inc_rfc1001_len(pSMB, byte_count);
4014 pSMB->ByteCount = cpu_to_le16(byte_count);
4016 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4017 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4018 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
4022 * BB: add logic to retry regular search if Unix search rejected
4023 * unexpectedly by server.
4025 /* BB: add code to handle unsupported level rc */
4026 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
4027 cifs_buf_release(pSMB);
4029 * BB: eventually could optimize out free and realloc of buf for
4033 goto findFirstRetry;
4036 /* decode response */
4037 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4039 cifs_buf_release(pSMB);
4043 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE);
4044 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4045 psrch_inf->smallBuf = false;
4046 psrch_inf->srch_entries_start = (char *)&pSMBr->hdr.Protocol +
4047 le16_to_cpu(pSMBr->t2.DataOffset);
4049 parms = (T2_FFIRST_RSP_PARMS *)((char *)&pSMBr->hdr.Protocol +
4050 le16_to_cpu(pSMBr->t2.ParameterOffset));
4051 psrch_inf->endOfSearch = !!parms->EndofSearch;
4053 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
4054 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4055 psrch_inf->entries_in_buffer;
4056 lnoff = le16_to_cpu(parms->LastNameOffset);
4057 if (CIFSMaxBufSize < lnoff) {
4058 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4059 psrch_inf->last_entry = NULL;
4061 psrch_inf->last_entry = psrch_inf->srch_entries_start + lnoff;
4063 *pnetfid = parms->SearchHandle;
4068 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4069 __u16 searchHandle, __u16 search_flags,
4070 struct cifs_search_info *psrch_inf)
4072 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4073 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4074 T2_FNEXT_RSP_PARMS *parms;
4075 unsigned int name_len;
4077 __u16 params, byte_count;
4078 char *response_data;
4082 cifs_dbg(FYI, "In FindNext\n");
4084 if (psrch_inf->endOfSearch)
4087 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4092 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4094 pSMB->TotalDataCount = 0; /* no EAs */
4095 pSMB->MaxParameterCount = cpu_to_le16(8);
4096 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4097 pSMB->MaxSetupCount = 0;
4101 pSMB->Reserved2 = 0;
4102 pSMB->ParameterOffset = cpu_to_le16(
4103 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4104 pSMB->DataCount = 0;
4105 pSMB->DataOffset = 0;
4106 pSMB->SetupCount = 1;
4107 pSMB->Reserved3 = 0;
4108 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4109 pSMB->SearchHandle = searchHandle; /* always kept as le */
4111 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4112 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4113 pSMB->ResumeKey = psrch_inf->resume_key;
4114 pSMB->SearchFlags = cpu_to_le16(search_flags);
4116 name_len = psrch_inf->resume_name_len;
4118 if (name_len < PATH_MAX) {
4119 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4120 byte_count += name_len;
4121 /* 14 byte parm len above enough for 2 byte null terminator */
4122 pSMB->ResumeFileName[name_len] = 0;
4123 pSMB->ResumeFileName[name_len+1] = 0;
4125 cifs_buf_release(pSMB);
4128 byte_count = params + 1 /* pad */ ;
4129 pSMB->TotalParameterCount = cpu_to_le16(params);
4130 pSMB->ParameterCount = pSMB->TotalParameterCount;
4131 inc_rfc1001_len(pSMB, byte_count);
4132 pSMB->ByteCount = cpu_to_le16(byte_count);
4134 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4135 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4136 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
4139 cifs_buf_release(pSMB);
4141 psrch_inf->endOfSearch = true;
4142 rc = 0; /* search probably was closed at end of search*/
4144 cifs_dbg(FYI, "FindNext returned = %d\n", rc);
4149 /* decode response */
4150 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4152 cifs_buf_release(pSMB);
4155 /* BB fixme add lock for file (srch_info) struct here */
4156 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE);
4157 response_data = (char *)&pSMBr->hdr.Protocol +
4158 le16_to_cpu(pSMBr->t2.ParameterOffset);
4159 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4160 response_data = (char *)&pSMBr->hdr.Protocol +
4161 le16_to_cpu(pSMBr->t2.DataOffset);
4163 if (psrch_inf->smallBuf)
4164 cifs_small_buf_release(psrch_inf->ntwrk_buf_start);
4166 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4168 psrch_inf->srch_entries_start = response_data;
4169 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4170 psrch_inf->smallBuf = false;
4171 psrch_inf->endOfSearch = !!parms->EndofSearch;
4172 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
4173 psrch_inf->index_of_last_entry += psrch_inf->entries_in_buffer;
4174 lnoff = le16_to_cpu(parms->LastNameOffset);
4175 if (CIFSMaxBufSize < lnoff) {
4176 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4177 psrch_inf->last_entry = NULL;
4179 psrch_inf->last_entry =
4180 psrch_inf->srch_entries_start + lnoff;
4182 /* BB fixme add unlock here */
4185 * BB: On error, should we leave previous search buf
4186 * (and count and last entry fields) intact or free the previous one?
4188 * Note: On -EAGAIN error only caller can retry on handle based calls
4189 * since file handle passed in no longer valid.
4195 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
4196 const __u16 searchHandle)
4199 FINDCLOSE_REQ *pSMB = NULL;
4201 cifs_dbg(FYI, "In CIFSSMBFindClose\n");
4202 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4204 /* no sense returning error if session restarted
4205 as file handle has been closed */
4211 pSMB->FileID = searchHandle;
4212 pSMB->ByteCount = 0;
4213 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4214 cifs_small_buf_release(pSMB);
4216 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
4218 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
4220 /* Since session is dead, search handle closed on server already */
4228 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
4229 const char *search_name, __u64 *inode_number,
4230 const struct nls_table *nls_codepage, int remap)
4233 TRANSACTION2_QPI_REQ *pSMB = NULL;
4234 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4235 int name_len, bytes_returned;
4236 __u16 params, byte_count;
4238 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
4242 GetInodeNumberRetry:
4243 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4248 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4250 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4251 search_name, PATH_MAX, nls_codepage,
4253 name_len++; /* trailing null */
4256 name_len = copy_path_name(pSMB->FileName, search_name);
4259 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4260 pSMB->TotalDataCount = 0;
4261 pSMB->MaxParameterCount = cpu_to_le16(2);
4262 /* BB find exact max data count below from sess structure BB */
4263 pSMB->MaxDataCount = cpu_to_le16(4000);
4264 pSMB->MaxSetupCount = 0;
4268 pSMB->Reserved2 = 0;
4269 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4270 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4271 pSMB->DataCount = 0;
4272 pSMB->DataOffset = 0;
4273 pSMB->SetupCount = 1;
4274 pSMB->Reserved3 = 0;
4275 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4276 byte_count = params + 1 /* pad */ ;
4277 pSMB->TotalParameterCount = cpu_to_le16(params);
4278 pSMB->ParameterCount = pSMB->TotalParameterCount;
4279 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4280 pSMB->Reserved4 = 0;
4281 inc_rfc1001_len(pSMB, byte_count);
4282 pSMB->ByteCount = cpu_to_le16(byte_count);
4284 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4285 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4287 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
4289 /* decode response */
4290 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4291 /* BB also check enough total bytes returned */
4292 if (rc || get_bcc(&pSMBr->hdr) < 2)
4293 /* If rc should we check for EOPNOSUPP and
4294 disable the srvino flag? or in caller? */
4295 rc = -EIO; /* bad smb */
4297 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4298 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4299 struct file_internal_info *pfinfo;
4300 /* BB Do we need a cast or hash here ? */
4302 cifs_dbg(FYI, "Invalid size ret in QryIntrnlInf\n");
4304 goto GetInodeNumOut;
4306 pfinfo = (struct file_internal_info *)
4307 (data_offset + (char *) &pSMBr->hdr.Protocol);
4308 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4312 cifs_buf_release(pSMB);
4314 goto GetInodeNumberRetry;
4319 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
4320 const char *search_name, struct dfs_info3_param **target_nodes,
4321 unsigned int *num_of_nodes,
4322 const struct nls_table *nls_codepage, int remap)
4324 /* TRANS2_GET_DFS_REFERRAL */
4325 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4326 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4330 __u16 params, byte_count;
4332 *target_nodes = NULL;
4334 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
4335 if (ses == NULL || ses->tcon_ipc == NULL)
4340 * Use smb_init_no_reconnect() instead of smb_init() as
4341 * CIFSGetDFSRefer() may be called from cifs_reconnect_tcon() and thus
4342 * causing an infinite recursion.
4344 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, ses->tcon_ipc,
4345 (void **)&pSMB, (void **)&pSMBr);
4349 /* server pointer checked in called function,
4350 but should never be null here anyway */
4351 pSMB->hdr.Mid = get_next_mid(ses->server);
4352 pSMB->hdr.Tid = ses->tcon_ipc->tid;
4353 pSMB->hdr.Uid = ses->Suid;
4354 if (ses->capabilities & CAP_STATUS32)
4355 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4356 if (ses->capabilities & CAP_DFS)
4357 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4359 if (ses->capabilities & CAP_UNICODE) {
4360 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4362 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4363 search_name, PATH_MAX, nls_codepage,
4365 name_len++; /* trailing null */
4367 } else { /* BB improve the check for buffer overruns BB */
4368 name_len = copy_path_name(pSMB->RequestFileName, search_name);
4371 if (ses->server->sign)
4372 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4374 pSMB->hdr.Uid = ses->Suid;
4376 params = 2 /* level */ + name_len /*includes null */ ;
4377 pSMB->TotalDataCount = 0;
4378 pSMB->DataCount = 0;
4379 pSMB->DataOffset = 0;
4380 pSMB->MaxParameterCount = 0;
4381 /* BB find exact max SMB PDU from sess structure BB */
4382 pSMB->MaxDataCount = cpu_to_le16(4000);
4383 pSMB->MaxSetupCount = 0;
4387 pSMB->Reserved2 = 0;
4388 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4389 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4390 pSMB->SetupCount = 1;
4391 pSMB->Reserved3 = 0;
4392 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4393 byte_count = params + 3 /* pad */ ;
4394 pSMB->ParameterCount = cpu_to_le16(params);
4395 pSMB->TotalParameterCount = pSMB->ParameterCount;
4396 pSMB->MaxReferralLevel = cpu_to_le16(3);
4397 inc_rfc1001_len(pSMB, byte_count);
4398 pSMB->ByteCount = cpu_to_le16(byte_count);
4400 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4401 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4403 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
4406 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4408 /* BB Also check if enough total bytes returned? */
4409 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4410 rc = -EIO; /* bad smb */
4414 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4415 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
4417 /* parse returned result into more usable form */
4418 rc = parse_dfs_referrals(&pSMBr->dfs_data,
4419 le16_to_cpu(pSMBr->t2.DataCount),
4420 num_of_nodes, target_nodes, nls_codepage,
4422 (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) != 0);
4425 cifs_buf_release(pSMB);
4433 /* Query File System Info such as free space to old servers such as Win 9x */
4435 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4436 struct kstatfs *FSData)
4438 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4439 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4440 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4441 FILE_SYSTEM_ALLOC_INFO *response_data;
4443 int bytes_returned = 0;
4444 __u16 params, byte_count;
4446 cifs_dbg(FYI, "OldQFSInfo\n");
4448 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4453 params = 2; /* level */
4454 pSMB->TotalDataCount = 0;
4455 pSMB->MaxParameterCount = cpu_to_le16(2);
4456 pSMB->MaxDataCount = cpu_to_le16(1000);
4457 pSMB->MaxSetupCount = 0;
4461 pSMB->Reserved2 = 0;
4462 byte_count = params + 1 /* pad */ ;
4463 pSMB->TotalParameterCount = cpu_to_le16(params);
4464 pSMB->ParameterCount = pSMB->TotalParameterCount;
4465 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4466 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4467 pSMB->DataCount = 0;
4468 pSMB->DataOffset = 0;
4469 pSMB->SetupCount = 1;
4470 pSMB->Reserved3 = 0;
4471 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4472 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4473 inc_rfc1001_len(pSMB, byte_count);
4474 pSMB->ByteCount = cpu_to_le16(byte_count);
4476 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4477 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4479 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4480 } else { /* decode response */
4481 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4483 if (rc || get_bcc(&pSMBr->hdr) < 18)
4484 rc = -EIO; /* bad smb */
4486 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4487 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n",
4488 get_bcc(&pSMBr->hdr), data_offset);
4490 response_data = (FILE_SYSTEM_ALLOC_INFO *)
4491 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4493 le16_to_cpu(response_data->BytesPerSector) *
4494 le32_to_cpu(response_data->
4495 SectorsPerAllocationUnit);
4497 * much prefer larger but if server doesn't report
4498 * a valid size than 4K is a reasonable minimum
4500 if (FSData->f_bsize < 512)
4501 FSData->f_bsize = 4096;
4504 le32_to_cpu(response_data->TotalAllocationUnits);
4505 FSData->f_bfree = FSData->f_bavail =
4506 le32_to_cpu(response_data->FreeAllocationUnits);
4507 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4508 (unsigned long long)FSData->f_blocks,
4509 (unsigned long long)FSData->f_bfree,
4513 cifs_buf_release(pSMB);
4516 goto oldQFSInfoRetry;
4522 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4523 struct kstatfs *FSData)
4525 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4526 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4527 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4528 FILE_SYSTEM_INFO *response_data;
4530 int bytes_returned = 0;
4531 __u16 params, byte_count;
4533 cifs_dbg(FYI, "In QFSInfo\n");
4535 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4540 params = 2; /* level */
4541 pSMB->TotalDataCount = 0;
4542 pSMB->MaxParameterCount = cpu_to_le16(2);
4543 pSMB->MaxDataCount = cpu_to_le16(1000);
4544 pSMB->MaxSetupCount = 0;
4548 pSMB->Reserved2 = 0;
4549 byte_count = params + 1 /* pad */ ;
4550 pSMB->TotalParameterCount = cpu_to_le16(params);
4551 pSMB->ParameterCount = pSMB->TotalParameterCount;
4552 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4553 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4554 pSMB->DataCount = 0;
4555 pSMB->DataOffset = 0;
4556 pSMB->SetupCount = 1;
4557 pSMB->Reserved3 = 0;
4558 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4559 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4560 inc_rfc1001_len(pSMB, byte_count);
4561 pSMB->ByteCount = cpu_to_le16(byte_count);
4563 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4564 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4566 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4567 } else { /* decode response */
4568 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4570 if (rc || get_bcc(&pSMBr->hdr) < 24)
4571 rc = -EIO; /* bad smb */
4573 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4577 *) (((char *) &pSMBr->hdr.Protocol) +
4580 le32_to_cpu(response_data->BytesPerSector) *
4581 le32_to_cpu(response_data->
4582 SectorsPerAllocationUnit);
4584 * much prefer larger but if server doesn't report
4585 * a valid size than 4K is a reasonable minimum
4587 if (FSData->f_bsize < 512)
4588 FSData->f_bsize = 4096;
4591 le64_to_cpu(response_data->TotalAllocationUnits);
4592 FSData->f_bfree = FSData->f_bavail =
4593 le64_to_cpu(response_data->FreeAllocationUnits);
4594 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4595 (unsigned long long)FSData->f_blocks,
4596 (unsigned long long)FSData->f_bfree,
4600 cifs_buf_release(pSMB);
4609 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
4611 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
4612 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4613 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4614 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4616 int bytes_returned = 0;
4617 __u16 params, byte_count;
4619 cifs_dbg(FYI, "In QFSAttributeInfo\n");
4621 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4626 params = 2; /* level */
4627 pSMB->TotalDataCount = 0;
4628 pSMB->MaxParameterCount = cpu_to_le16(2);
4629 /* BB find exact max SMB PDU from sess structure BB */
4630 pSMB->MaxDataCount = cpu_to_le16(1000);
4631 pSMB->MaxSetupCount = 0;
4635 pSMB->Reserved2 = 0;
4636 byte_count = params + 1 /* pad */ ;
4637 pSMB->TotalParameterCount = cpu_to_le16(params);
4638 pSMB->ParameterCount = pSMB->TotalParameterCount;
4639 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4640 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4641 pSMB->DataCount = 0;
4642 pSMB->DataOffset = 0;
4643 pSMB->SetupCount = 1;
4644 pSMB->Reserved3 = 0;
4645 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4646 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4647 inc_rfc1001_len(pSMB, byte_count);
4648 pSMB->ByteCount = cpu_to_le16(byte_count);
4650 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4651 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4653 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
4654 } else { /* decode response */
4655 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4657 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4658 /* BB also check if enough bytes returned */
4659 rc = -EIO; /* bad smb */
4661 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4663 (FILE_SYSTEM_ATTRIBUTE_INFO
4664 *) (((char *) &pSMBr->hdr.Protocol) +
4666 memcpy(&tcon->fsAttrInfo, response_data,
4667 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4670 cifs_buf_release(pSMB);
4673 goto QFSAttributeRetry;
4679 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
4681 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4682 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4683 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4684 FILE_SYSTEM_DEVICE_INFO *response_data;
4686 int bytes_returned = 0;
4687 __u16 params, byte_count;
4689 cifs_dbg(FYI, "In QFSDeviceInfo\n");
4691 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4696 params = 2; /* level */
4697 pSMB->TotalDataCount = 0;
4698 pSMB->MaxParameterCount = cpu_to_le16(2);
4699 /* BB find exact max SMB PDU from sess structure BB */
4700 pSMB->MaxDataCount = cpu_to_le16(1000);
4701 pSMB->MaxSetupCount = 0;
4705 pSMB->Reserved2 = 0;
4706 byte_count = params + 1 /* pad */ ;
4707 pSMB->TotalParameterCount = cpu_to_le16(params);
4708 pSMB->ParameterCount = pSMB->TotalParameterCount;
4709 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4710 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4712 pSMB->DataCount = 0;
4713 pSMB->DataOffset = 0;
4714 pSMB->SetupCount = 1;
4715 pSMB->Reserved3 = 0;
4716 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4717 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4718 inc_rfc1001_len(pSMB, byte_count);
4719 pSMB->ByteCount = cpu_to_le16(byte_count);
4721 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4722 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4724 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
4725 } else { /* decode response */
4726 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4728 if (rc || get_bcc(&pSMBr->hdr) <
4729 sizeof(FILE_SYSTEM_DEVICE_INFO))
4730 rc = -EIO; /* bad smb */
4732 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4734 (FILE_SYSTEM_DEVICE_INFO *)
4735 (((char *) &pSMBr->hdr.Protocol) +
4737 memcpy(&tcon->fsDevInfo, response_data,
4738 sizeof(FILE_SYSTEM_DEVICE_INFO));
4741 cifs_buf_release(pSMB);
4744 goto QFSDeviceRetry;
4750 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
4752 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
4753 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4754 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4755 FILE_SYSTEM_UNIX_INFO *response_data;
4757 int bytes_returned = 0;
4758 __u16 params, byte_count;
4760 cifs_dbg(FYI, "In QFSUnixInfo\n");
4762 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
4763 (void **) &pSMB, (void **) &pSMBr);
4767 params = 2; /* level */
4768 pSMB->TotalDataCount = 0;
4769 pSMB->DataCount = 0;
4770 pSMB->DataOffset = 0;
4771 pSMB->MaxParameterCount = cpu_to_le16(2);
4772 /* BB find exact max SMB PDU from sess structure BB */
4773 pSMB->MaxDataCount = cpu_to_le16(100);
4774 pSMB->MaxSetupCount = 0;
4778 pSMB->Reserved2 = 0;
4779 byte_count = params + 1 /* pad */ ;
4780 pSMB->ParameterCount = cpu_to_le16(params);
4781 pSMB->TotalParameterCount = pSMB->ParameterCount;
4782 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4783 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4784 pSMB->SetupCount = 1;
4785 pSMB->Reserved3 = 0;
4786 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4787 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4788 inc_rfc1001_len(pSMB, byte_count);
4789 pSMB->ByteCount = cpu_to_le16(byte_count);
4791 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4792 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4794 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
4795 } else { /* decode response */
4796 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4798 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4799 rc = -EIO; /* bad smb */
4801 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4803 (FILE_SYSTEM_UNIX_INFO
4804 *) (((char *) &pSMBr->hdr.Protocol) +
4806 memcpy(&tcon->fsUnixInfo, response_data,
4807 sizeof(FILE_SYSTEM_UNIX_INFO));
4810 cifs_buf_release(pSMB);
4820 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
4822 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
4823 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4824 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4826 int bytes_returned = 0;
4827 __u16 params, param_offset, offset, byte_count;
4829 cifs_dbg(FYI, "In SETFSUnixInfo\n");
4831 /* BB switch to small buf init to save memory */
4832 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
4833 (void **) &pSMB, (void **) &pSMBr);
4837 params = 4; /* 2 bytes zero followed by info level. */
4838 pSMB->MaxSetupCount = 0;
4842 pSMB->Reserved2 = 0;
4843 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4845 offset = param_offset + params;
4847 pSMB->MaxParameterCount = cpu_to_le16(4);
4848 /* BB find exact max SMB PDU from sess structure BB */
4849 pSMB->MaxDataCount = cpu_to_le16(100);
4850 pSMB->SetupCount = 1;
4851 pSMB->Reserved3 = 0;
4852 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4853 byte_count = 1 /* pad */ + params + 12;
4855 pSMB->DataCount = cpu_to_le16(12);
4856 pSMB->ParameterCount = cpu_to_le16(params);
4857 pSMB->TotalDataCount = pSMB->DataCount;
4858 pSMB->TotalParameterCount = pSMB->ParameterCount;
4859 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4860 pSMB->DataOffset = cpu_to_le16(offset);
4864 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4867 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4868 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4869 pSMB->ClientUnixCap = cpu_to_le64(cap);
4871 inc_rfc1001_len(pSMB, byte_count);
4872 pSMB->ByteCount = cpu_to_le16(byte_count);
4874 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4875 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4877 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
4878 } else { /* decode response */
4879 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4881 rc = -EIO; /* bad smb */
4883 cifs_buf_release(pSMB);
4886 goto SETFSUnixRetry;
4894 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
4895 struct kstatfs *FSData)
4897 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
4898 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4899 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4900 FILE_SYSTEM_POSIX_INFO *response_data;
4902 int bytes_returned = 0;
4903 __u16 params, byte_count;
4905 cifs_dbg(FYI, "In QFSPosixInfo\n");
4907 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4912 params = 2; /* level */
4913 pSMB->TotalDataCount = 0;
4914 pSMB->DataCount = 0;
4915 pSMB->DataOffset = 0;
4916 pSMB->MaxParameterCount = cpu_to_le16(2);
4917 /* BB find exact max SMB PDU from sess structure BB */
4918 pSMB->MaxDataCount = cpu_to_le16(100);
4919 pSMB->MaxSetupCount = 0;
4923 pSMB->Reserved2 = 0;
4924 byte_count = params + 1 /* pad */ ;
4925 pSMB->ParameterCount = cpu_to_le16(params);
4926 pSMB->TotalParameterCount = pSMB->ParameterCount;
4927 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4928 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4929 pSMB->SetupCount = 1;
4930 pSMB->Reserved3 = 0;
4931 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4932 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4933 inc_rfc1001_len(pSMB, byte_count);
4934 pSMB->ByteCount = cpu_to_le16(byte_count);
4936 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4937 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4939 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
4940 } else { /* decode response */
4941 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4943 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4944 rc = -EIO; /* bad smb */
4946 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4948 (FILE_SYSTEM_POSIX_INFO
4949 *) (((char *) &pSMBr->hdr.Protocol) +
4952 le32_to_cpu(response_data->BlockSize);
4954 * much prefer larger but if server doesn't report
4955 * a valid size than 4K is a reasonable minimum
4957 if (FSData->f_bsize < 512)
4958 FSData->f_bsize = 4096;
4961 le64_to_cpu(response_data->TotalBlocks);
4963 le64_to_cpu(response_data->BlocksAvail);
4964 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4965 FSData->f_bavail = FSData->f_bfree;
4968 le64_to_cpu(response_data->UserBlocksAvail);
4970 if (response_data->TotalFileNodes != cpu_to_le64(-1))
4972 le64_to_cpu(response_data->TotalFileNodes);
4973 if (response_data->FreeFileNodes != cpu_to_le64(-1))
4975 le64_to_cpu(response_data->FreeFileNodes);
4978 cifs_buf_release(pSMB);
4988 * We can not use write of zero bytes trick to set file size due to need for
4989 * large file support. Also note that this SetPathInfo is preferred to
4990 * SetFileInfo based method in next routine which is only needed to work around
4991 * a sharing violation bugin Samba which this routine can run into.
4994 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
4995 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
4996 bool set_allocation)
4998 struct smb_com_transaction2_spi_req *pSMB = NULL;
4999 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5000 struct file_end_of_file_info *parm_data;
5003 int bytes_returned = 0;
5004 int remap = cifs_remap(cifs_sb);
5006 __u16 params, byte_count, data_count, param_offset, offset;
5008 cifs_dbg(FYI, "In SetEOF\n");
5010 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5015 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5017 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5018 PATH_MAX, cifs_sb->local_nls, remap);
5019 name_len++; /* trailing null */
5022 name_len = copy_path_name(pSMB->FileName, file_name);
5024 params = 6 + name_len;
5025 data_count = sizeof(struct file_end_of_file_info);
5026 pSMB->MaxParameterCount = cpu_to_le16(2);
5027 pSMB->MaxDataCount = cpu_to_le16(4100);
5028 pSMB->MaxSetupCount = 0;
5032 pSMB->Reserved2 = 0;
5033 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5034 InformationLevel) - 4;
5035 offset = param_offset + params;
5036 if (set_allocation) {
5037 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5038 pSMB->InformationLevel =
5039 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5041 pSMB->InformationLevel =
5042 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5043 } else /* Set File Size */ {
5044 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5045 pSMB->InformationLevel =
5046 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5048 pSMB->InformationLevel =
5049 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5053 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5055 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5056 pSMB->DataOffset = cpu_to_le16(offset);
5057 pSMB->SetupCount = 1;
5058 pSMB->Reserved3 = 0;
5059 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5060 byte_count = 3 /* pad */ + params + data_count;
5061 pSMB->DataCount = cpu_to_le16(data_count);
5062 pSMB->TotalDataCount = pSMB->DataCount;
5063 pSMB->ParameterCount = cpu_to_le16(params);
5064 pSMB->TotalParameterCount = pSMB->ParameterCount;
5065 pSMB->Reserved4 = 0;
5066 inc_rfc1001_len(pSMB, byte_count);
5067 parm_data->FileSize = cpu_to_le64(size);
5068 pSMB->ByteCount = cpu_to_le16(byte_count);
5069 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5070 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5072 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
5074 cifs_buf_release(pSMB);
5083 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5084 struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
5086 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5087 struct file_end_of_file_info *parm_data;
5089 __u16 params, param_offset, offset, byte_count, count;
5091 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5093 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5098 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5099 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
5102 pSMB->MaxSetupCount = 0;
5106 pSMB->Reserved2 = 0;
5107 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5108 offset = param_offset + params;
5110 count = sizeof(struct file_end_of_file_info);
5111 pSMB->MaxParameterCount = cpu_to_le16(2);
5112 /* BB find exact max SMB PDU from sess structure BB */
5113 pSMB->MaxDataCount = cpu_to_le16(1000);
5114 pSMB->SetupCount = 1;
5115 pSMB->Reserved3 = 0;
5116 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5117 byte_count = 3 /* pad */ + params + count;
5118 pSMB->DataCount = cpu_to_le16(count);
5119 pSMB->ParameterCount = cpu_to_le16(params);
5120 pSMB->TotalDataCount = pSMB->DataCount;
5121 pSMB->TotalParameterCount = pSMB->ParameterCount;
5122 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5123 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5125 (struct file_end_of_file_info *)(((char *)pSMB) + offset + 4);
5126 pSMB->DataOffset = cpu_to_le16(offset);
5127 parm_data->FileSize = cpu_to_le64(size);
5128 pSMB->Fid = cfile->fid.netfid;
5129 if (set_allocation) {
5130 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5131 pSMB->InformationLevel =
5132 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5134 pSMB->InformationLevel =
5135 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5136 } else /* Set File Size */ {
5137 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5138 pSMB->InformationLevel =
5139 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5141 pSMB->InformationLevel =
5142 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5144 pSMB->Reserved4 = 0;
5145 inc_rfc1001_len(pSMB, byte_count);
5146 pSMB->ByteCount = cpu_to_le16(byte_count);
5147 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5148 cifs_small_buf_release(pSMB);
5150 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5154 /* Note: On -EAGAIN error only caller can retry on handle based calls
5155 since file handle passed in no longer valid */
5160 /* Some legacy servers such as NT4 require that the file times be set on
5161 an open handle, rather than by pathname - this is awkward due to
5162 potential access conflicts on the open, but it is unavoidable for these
5163 old servers since the only other choice is to go from 100 nanosecond DCE
5164 time and resort to the original setpathinfo level which takes the ancient
5165 DOS time format with 2 second granularity */
5167 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5168 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5170 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5173 __u16 params, param_offset, offset, byte_count, count;
5175 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
5176 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5181 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5182 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5185 pSMB->MaxSetupCount = 0;
5189 pSMB->Reserved2 = 0;
5190 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5191 offset = param_offset + params;
5193 data_offset = (char *)pSMB +
5194 offsetof(struct smb_hdr, Protocol) + offset;
5196 count = sizeof(FILE_BASIC_INFO);
5197 pSMB->MaxParameterCount = cpu_to_le16(2);
5198 /* BB find max SMB PDU from sess */
5199 pSMB->MaxDataCount = cpu_to_le16(1000);
5200 pSMB->SetupCount = 1;
5201 pSMB->Reserved3 = 0;
5202 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5203 byte_count = 3 /* pad */ + params + count;
5204 pSMB->DataCount = cpu_to_le16(count);
5205 pSMB->ParameterCount = cpu_to_le16(params);
5206 pSMB->TotalDataCount = pSMB->DataCount;
5207 pSMB->TotalParameterCount = pSMB->ParameterCount;
5208 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5209 pSMB->DataOffset = cpu_to_le16(offset);
5211 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5212 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5214 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5215 pSMB->Reserved4 = 0;
5216 inc_rfc1001_len(pSMB, byte_count);
5217 pSMB->ByteCount = cpu_to_le16(byte_count);
5218 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5219 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5220 cifs_small_buf_release(pSMB);
5222 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5225 /* Note: On -EAGAIN error only caller can retry on handle based calls
5226 since file handle passed in no longer valid */
5232 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
5233 bool delete_file, __u16 fid, __u32 pid_of_opener)
5235 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5238 __u16 params, param_offset, offset, byte_count, count;
5240 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
5241 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5246 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5247 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5250 pSMB->MaxSetupCount = 0;
5254 pSMB->Reserved2 = 0;
5255 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5256 offset = param_offset + params;
5258 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5259 data_offset = (char *)(pSMB) + offset + 4;
5262 pSMB->MaxParameterCount = cpu_to_le16(2);
5263 /* BB find max SMB PDU from sess */
5264 pSMB->MaxDataCount = cpu_to_le16(1000);
5265 pSMB->SetupCount = 1;
5266 pSMB->Reserved3 = 0;
5267 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5268 byte_count = 3 /* pad */ + params + count;
5269 pSMB->DataCount = cpu_to_le16(count);
5270 pSMB->ParameterCount = cpu_to_le16(params);
5271 pSMB->TotalDataCount = pSMB->DataCount;
5272 pSMB->TotalParameterCount = pSMB->ParameterCount;
5273 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5274 pSMB->DataOffset = cpu_to_le16(offset);
5276 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5277 pSMB->Reserved4 = 0;
5278 inc_rfc1001_len(pSMB, byte_count);
5279 pSMB->ByteCount = cpu_to_le16(byte_count);
5280 *data_offset = delete_file ? 1 : 0;
5281 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5282 cifs_small_buf_release(pSMB);
5284 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
5290 CIFSSMBSetPathInfoFB(const unsigned int xid, struct cifs_tcon *tcon,
5291 const char *fileName, const FILE_BASIC_INFO *data,
5292 const struct nls_table *nls_codepage,
5293 struct cifs_sb_info *cifs_sb)
5296 struct cifs_open_parms oparms;
5297 struct cifs_fid fid;
5300 oparms = (struct cifs_open_parms) {
5303 .desired_access = GENERIC_WRITE,
5304 .create_options = cifs_create_options(cifs_sb, 0),
5305 .disposition = FILE_OPEN,
5310 rc = CIFS_open(xid, &oparms, &oplock, NULL);
5314 rc = CIFSSMBSetFileInfo(xid, tcon, data, fid.netfid, current->tgid);
5315 CIFSSMBClose(xid, tcon, fid.netfid);
5322 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5323 const char *fileName, const FILE_BASIC_INFO *data,
5324 const struct nls_table *nls_codepage,
5325 struct cifs_sb_info *cifs_sb)
5327 TRANSACTION2_SPI_REQ *pSMB = NULL;
5328 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5331 int bytes_returned = 0;
5333 __u16 params, param_offset, offset, byte_count, count;
5334 int remap = cifs_remap(cifs_sb);
5336 cifs_dbg(FYI, "In SetTimes\n");
5339 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5344 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5346 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5347 PATH_MAX, nls_codepage, remap);
5348 name_len++; /* trailing null */
5351 name_len = copy_path_name(pSMB->FileName, fileName);
5354 params = 6 + name_len;
5355 count = sizeof(FILE_BASIC_INFO);
5356 pSMB->MaxParameterCount = cpu_to_le16(2);
5357 /* BB find max SMB PDU from sess structure BB */
5358 pSMB->MaxDataCount = cpu_to_le16(1000);
5359 pSMB->MaxSetupCount = 0;
5363 pSMB->Reserved2 = 0;
5364 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5365 InformationLevel) - 4;
5366 offset = param_offset + params;
5367 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5368 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5369 pSMB->DataOffset = cpu_to_le16(offset);
5370 pSMB->SetupCount = 1;
5371 pSMB->Reserved3 = 0;
5372 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5373 byte_count = 3 /* pad */ + params + count;
5375 pSMB->DataCount = cpu_to_le16(count);
5376 pSMB->ParameterCount = cpu_to_le16(params);
5377 pSMB->TotalDataCount = pSMB->DataCount;
5378 pSMB->TotalParameterCount = pSMB->ParameterCount;
5379 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5380 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5382 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5383 pSMB->Reserved4 = 0;
5384 inc_rfc1001_len(pSMB, byte_count);
5385 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5386 pSMB->ByteCount = cpu_to_le16(byte_count);
5387 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5388 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5390 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
5392 cifs_buf_release(pSMB);
5397 if (rc == -EOPNOTSUPP)
5398 return CIFSSMBSetPathInfoFB(xid, tcon, fileName, data,
5399 nls_codepage, cifs_sb);
5405 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5406 const struct cifs_unix_set_info_args *args)
5408 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
5409 u64 mode = args->mode;
5411 if (uid_valid(args->uid))
5412 uid = from_kuid(&init_user_ns, args->uid);
5413 if (gid_valid(args->gid))
5414 gid = from_kgid(&init_user_ns, args->gid);
5417 * Samba server ignores set of file size to zero due to bugs in some
5418 * older clients, but we should be precise - we use SetFileSize to
5419 * set file size and do not want to truncate file size to zero
5420 * accidentally as happened on one Samba server beta by putting
5421 * zero instead of -1 here
5423 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5424 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5425 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5426 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5427 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5428 data_offset->Uid = cpu_to_le64(uid);
5429 data_offset->Gid = cpu_to_le64(gid);
5430 /* better to leave device as zero when it is */
5431 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5432 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5433 data_offset->Permissions = cpu_to_le64(mode);
5436 data_offset->Type = cpu_to_le32(UNIX_FILE);
5437 else if (S_ISDIR(mode))
5438 data_offset->Type = cpu_to_le32(UNIX_DIR);
5439 else if (S_ISLNK(mode))
5440 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5441 else if (S_ISCHR(mode))
5442 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5443 else if (S_ISBLK(mode))
5444 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5445 else if (S_ISFIFO(mode))
5446 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5447 else if (S_ISSOCK(mode))
5448 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5452 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5453 const struct cifs_unix_set_info_args *args,
5454 u16 fid, u32 pid_of_opener)
5456 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5459 u16 params, param_offset, offset, byte_count, count;
5461 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
5462 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5467 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5468 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5471 pSMB->MaxSetupCount = 0;
5475 pSMB->Reserved2 = 0;
5476 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5477 offset = param_offset + params;
5479 data_offset = (char *)pSMB +
5480 offsetof(struct smb_hdr, Protocol) + offset;
5482 count = sizeof(FILE_UNIX_BASIC_INFO);
5484 pSMB->MaxParameterCount = cpu_to_le16(2);
5485 /* BB find max SMB PDU from sess */
5486 pSMB->MaxDataCount = cpu_to_le16(1000);
5487 pSMB->SetupCount = 1;
5488 pSMB->Reserved3 = 0;
5489 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5490 byte_count = 3 /* pad */ + params + count;
5491 pSMB->DataCount = cpu_to_le16(count);
5492 pSMB->ParameterCount = cpu_to_le16(params);
5493 pSMB->TotalDataCount = pSMB->DataCount;
5494 pSMB->TotalParameterCount = pSMB->ParameterCount;
5495 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5496 pSMB->DataOffset = cpu_to_le16(offset);
5498 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5499 pSMB->Reserved4 = 0;
5500 inc_rfc1001_len(pSMB, byte_count);
5501 pSMB->ByteCount = cpu_to_le16(byte_count);
5503 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
5505 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5506 cifs_small_buf_release(pSMB);
5508 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5511 /* Note: On -EAGAIN error only caller can retry on handle based calls
5512 since file handle passed in no longer valid */
5518 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5519 const char *file_name,
5520 const struct cifs_unix_set_info_args *args,
5521 const struct nls_table *nls_codepage, int remap)
5523 TRANSACTION2_SPI_REQ *pSMB = NULL;
5524 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5527 int bytes_returned = 0;
5528 FILE_UNIX_BASIC_INFO *data_offset;
5529 __u16 params, param_offset, offset, count, byte_count;
5531 cifs_dbg(FYI, "In SetUID/GID/Mode\n");
5533 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5538 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5540 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5541 PATH_MAX, nls_codepage, remap);
5542 name_len++; /* trailing null */
5545 name_len = copy_path_name(pSMB->FileName, file_name);
5548 params = 6 + name_len;
5549 count = sizeof(FILE_UNIX_BASIC_INFO);
5550 pSMB->MaxParameterCount = cpu_to_le16(2);
5551 /* BB find max SMB PDU from sess structure BB */
5552 pSMB->MaxDataCount = cpu_to_le16(1000);
5553 pSMB->MaxSetupCount = 0;
5557 pSMB->Reserved2 = 0;
5558 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5559 InformationLevel) - 4;
5560 offset = param_offset + params;
5561 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5562 data_offset = (FILE_UNIX_BASIC_INFO *)((char *) pSMB + offset + 4);
5563 memset(data_offset, 0, count);
5564 pSMB->DataOffset = cpu_to_le16(offset);
5565 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5566 pSMB->SetupCount = 1;
5567 pSMB->Reserved3 = 0;
5568 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5569 byte_count = 3 /* pad */ + params + count;
5570 pSMB->ParameterCount = cpu_to_le16(params);
5571 pSMB->DataCount = cpu_to_le16(count);
5572 pSMB->TotalParameterCount = pSMB->ParameterCount;
5573 pSMB->TotalDataCount = pSMB->DataCount;
5574 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5575 pSMB->Reserved4 = 0;
5576 inc_rfc1001_len(pSMB, byte_count);
5578 cifs_fill_unix_set_info(data_offset, args);
5580 pSMB->ByteCount = cpu_to_le16(byte_count);
5581 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5582 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5584 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
5586 cifs_buf_release(pSMB);
5592 #ifdef CONFIG_CIFS_XATTR
5594 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
5595 * function used by listxattr and getxattr type calls. When ea_name is set,
5596 * it looks for that attribute name and stuffs that value into the EAData
5597 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
5598 * buffer. In both cases, the return value is either the length of the
5599 * resulting data or a negative error code. If EAData is a NULL pointer then
5600 * the data isn't copied to it, but the length is returned.
5603 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
5604 const unsigned char *searchName, const unsigned char *ea_name,
5605 char *EAData, size_t buf_size,
5606 struct cifs_sb_info *cifs_sb)
5608 /* BB assumes one setup word */
5609 TRANSACTION2_QPI_REQ *pSMB = NULL;
5610 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5611 int remap = cifs_remap(cifs_sb);
5612 struct nls_table *nls_codepage = cifs_sb->local_nls;
5616 struct fealist *ea_response_data;
5617 struct fea *temp_fea;
5620 __u16 params, byte_count, data_offset;
5621 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
5623 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
5625 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5630 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5632 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
5633 PATH_MAX, nls_codepage, remap);
5634 list_len++; /* trailing null */
5637 list_len = copy_path_name(pSMB->FileName, searchName);
5640 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
5641 pSMB->TotalDataCount = 0;
5642 pSMB->MaxParameterCount = cpu_to_le16(2);
5643 /* BB find exact max SMB PDU from sess structure BB */
5644 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
5645 pSMB->MaxSetupCount = 0;
5649 pSMB->Reserved2 = 0;
5650 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5651 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5652 pSMB->DataCount = 0;
5653 pSMB->DataOffset = 0;
5654 pSMB->SetupCount = 1;
5655 pSMB->Reserved3 = 0;
5656 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5657 byte_count = params + 1 /* pad */ ;
5658 pSMB->TotalParameterCount = cpu_to_le16(params);
5659 pSMB->ParameterCount = pSMB->TotalParameterCount;
5660 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5661 pSMB->Reserved4 = 0;
5662 inc_rfc1001_len(pSMB, byte_count);
5663 pSMB->ByteCount = cpu_to_le16(byte_count);
5665 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5666 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5668 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
5673 /* BB also check enough total bytes returned */
5674 /* BB we need to improve the validity checking
5675 of these trans2 responses */
5677 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5678 if (rc || get_bcc(&pSMBr->hdr) < 4) {
5679 rc = -EIO; /* bad smb */
5683 /* check that length of list is not more than bcc */
5684 /* check that each entry does not go beyond length
5686 /* check that each element of each entry does not
5687 go beyond end of list */
5688 /* validate_trans2_offsets() */
5689 /* BB check if start of smb + data_offset > &bcc+ bcc */
5691 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5692 ea_response_data = (struct fealist *)
5693 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5695 list_len = le32_to_cpu(ea_response_data->list_len);
5696 cifs_dbg(FYI, "ea length %d\n", list_len);
5697 if (list_len <= 8) {
5698 cifs_dbg(FYI, "empty EA list returned from server\n");
5699 /* didn't find the named attribute */
5705 /* make sure list_len doesn't go past end of SMB */
5706 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
5707 if ((char *)ea_response_data + list_len > end_of_smb) {
5708 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
5713 /* account for ea list len */
5715 temp_fea = &ea_response_data->list;
5716 temp_ptr = (char *)temp_fea;
5717 while (list_len > 0) {
5718 unsigned int name_len;
5723 /* make sure we can read name_len and value_len */
5725 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
5730 name_len = temp_fea->name_len;
5731 value_len = le16_to_cpu(temp_fea->value_len);
5732 list_len -= name_len + 1 + value_len;
5734 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
5740 if (ea_name_len == name_len &&
5741 memcmp(ea_name, temp_ptr, name_len) == 0) {
5742 temp_ptr += name_len + 1;
5746 if ((size_t)value_len > buf_size) {
5750 memcpy(EAData, temp_ptr, value_len);
5754 /* account for prefix user. and trailing null */
5755 rc += (5 + 1 + name_len);
5756 if (rc < (int) buf_size) {
5757 memcpy(EAData, "user.", 5);
5759 memcpy(EAData, temp_ptr, name_len);
5761 /* null terminate name */
5764 } else if (buf_size == 0) {
5765 /* skip copy - calc size only */
5767 /* stop before overrun buffer */
5772 temp_ptr += name_len + 1 + value_len;
5773 temp_fea = (struct fea *)temp_ptr;
5776 /* didn't find the named attribute */
5781 cifs_buf_release(pSMB);
5789 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
5790 const char *fileName, const char *ea_name, const void *ea_value,
5791 const __u16 ea_value_len, const struct nls_table *nls_codepage,
5792 struct cifs_sb_info *cifs_sb)
5794 struct smb_com_transaction2_spi_req *pSMB = NULL;
5795 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5796 struct fealist *parm_data;
5799 int bytes_returned = 0;
5800 __u16 params, param_offset, byte_count, offset, count;
5801 int remap = cifs_remap(cifs_sb);
5803 cifs_dbg(FYI, "In SetEA\n");
5805 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5810 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5812 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5813 PATH_MAX, nls_codepage, remap);
5814 name_len++; /* trailing null */
5817 name_len = copy_path_name(pSMB->FileName, fileName);
5820 params = 6 + name_len;
5822 /* done calculating parms using name_len of file name,
5823 now use name_len to calculate length of ea name
5824 we are going to create in the inode xattrs */
5825 if (ea_name == NULL)
5828 name_len = strnlen(ea_name, 255);
5830 count = sizeof(*parm_data) + 1 + ea_value_len + name_len;
5831 pSMB->MaxParameterCount = cpu_to_le16(2);
5832 /* BB find max SMB PDU from sess */
5833 pSMB->MaxDataCount = cpu_to_le16(1000);
5834 pSMB->MaxSetupCount = 0;
5838 pSMB->Reserved2 = 0;
5839 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5840 InformationLevel) - 4;
5841 offset = param_offset + params;
5842 pSMB->InformationLevel =
5843 cpu_to_le16(SMB_SET_FILE_EA);
5845 parm_data = (void *)pSMB + offsetof(struct smb_hdr, Protocol) + offset;
5846 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5847 pSMB->DataOffset = cpu_to_le16(offset);
5848 pSMB->SetupCount = 1;
5849 pSMB->Reserved3 = 0;
5850 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5851 byte_count = 3 /* pad */ + params + count;
5852 pSMB->DataCount = cpu_to_le16(count);
5853 parm_data->list_len = cpu_to_le32(count);
5854 parm_data->list.EA_flags = 0;
5855 /* we checked above that name len is less than 255 */
5856 parm_data->list.name_len = (__u8)name_len;
5857 /* EA names are always ASCII */
5859 strncpy(parm_data->list.name, ea_name, name_len);
5860 parm_data->list.name[name_len] = '\0';
5861 parm_data->list.value_len = cpu_to_le16(ea_value_len);
5862 /* caller ensures that ea_value_len is less than 64K but
5863 we need to ensure that it fits within the smb */
5865 /*BB add length check to see if it would fit in
5866 negotiated SMB buffer size BB */
5867 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5869 memcpy(parm_data->list.name + name_len + 1,
5870 ea_value, ea_value_len);
5872 pSMB->TotalDataCount = pSMB->DataCount;
5873 pSMB->ParameterCount = cpu_to_le16(params);
5874 pSMB->TotalParameterCount = pSMB->ParameterCount;
5875 pSMB->Reserved4 = 0;
5876 inc_rfc1001_len(pSMB, byte_count);
5877 pSMB->ByteCount = cpu_to_le16(byte_count);
5878 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5879 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5881 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
5883 cifs_buf_release(pSMB);