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);
2153 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
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;
2534 CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2535 const char *from_name, const char *to_name,
2536 struct cifs_sb_info *cifs_sb)
2539 NT_RENAME_REQ *pSMB = NULL;
2540 RENAME_RSP *pSMBr = NULL;
2542 int name_len, name_len2;
2544 int remap = cifs_remap(cifs_sb);
2546 cifs_dbg(FYI, "In CIFSCreateHardLink\n");
2547 winCreateHardLinkRetry:
2549 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2554 pSMB->SearchAttributes =
2555 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2557 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2558 pSMB->ClusterCount = 0;
2560 pSMB->BufferFormat = 0x04;
2562 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2564 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
2565 PATH_MAX, cifs_sb->local_nls, remap);
2566 name_len++; /* trailing null */
2569 /* protocol specifies ASCII buffer format (0x04) for unicode */
2570 pSMB->OldFileName[name_len] = 0x04;
2571 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
2573 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2574 to_name, PATH_MAX, cifs_sb->local_nls,
2576 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2577 name_len2 *= 2; /* convert to bytes */
2579 name_len = copy_path_name(pSMB->OldFileName, from_name);
2580 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2581 name_len2 = copy_path_name(pSMB->OldFileName+name_len+1, to_name);
2582 name_len2++; /* signature byte */
2585 count = 1 /* string type byte */ + name_len + name_len2;
2586 inc_rfc1001_len(pSMB, count);
2587 pSMB->ByteCount = cpu_to_le16(count);
2589 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2590 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2591 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2593 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
2595 cifs_buf_release(pSMB);
2597 goto winCreateHardLinkRetry;
2603 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
2604 const unsigned char *searchName, char **symlinkinfo,
2605 const struct nls_table *nls_codepage, int remap)
2607 /* SMB_QUERY_FILE_UNIX_LINK */
2608 TRANSACTION2_QPI_REQ *pSMB = NULL;
2609 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2613 __u16 params, byte_count;
2616 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
2619 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2624 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2626 cifsConvertToUTF16((__le16 *) pSMB->FileName,
2627 searchName, PATH_MAX, nls_codepage,
2629 name_len++; /* trailing null */
2632 name_len = copy_path_name(pSMB->FileName, searchName);
2635 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2636 pSMB->TotalDataCount = 0;
2637 pSMB->MaxParameterCount = cpu_to_le16(2);
2638 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
2639 pSMB->MaxSetupCount = 0;
2643 pSMB->Reserved2 = 0;
2644 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2645 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2646 pSMB->DataCount = 0;
2647 pSMB->DataOffset = 0;
2648 pSMB->SetupCount = 1;
2649 pSMB->Reserved3 = 0;
2650 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2651 byte_count = params + 1 /* pad */ ;
2652 pSMB->TotalParameterCount = cpu_to_le16(params);
2653 pSMB->ParameterCount = pSMB->TotalParameterCount;
2654 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2655 pSMB->Reserved4 = 0;
2656 inc_rfc1001_len(pSMB, byte_count);
2657 pSMB->ByteCount = cpu_to_le16(byte_count);
2659 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2660 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2662 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
2664 /* decode response */
2666 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2667 /* BB also check enough total bytes returned */
2668 if (rc || get_bcc(&pSMBr->hdr) < 2)
2672 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2674 data_start = ((char *) &pSMBr->hdr.Protocol) +
2675 le16_to_cpu(pSMBr->t2.DataOffset);
2677 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2682 /* BB FIXME investigate remapping reserved chars here */
2683 *symlinkinfo = cifs_strndup_from_utf16(data_start,
2684 count, is_unicode, nls_codepage);
2689 cifs_buf_release(pSMB);
2691 goto querySymLinkRetry;
2695 int cifs_query_reparse_point(const unsigned int xid,
2696 struct cifs_tcon *tcon,
2697 struct cifs_sb_info *cifs_sb,
2698 const char *full_path,
2699 u32 *tag, struct kvec *rsp,
2702 struct cifs_open_parms oparms;
2703 TRANSACT_IOCTL_REQ *io_req = NULL;
2704 TRANSACT_IOCTL_RSP *io_rsp = NULL;
2705 struct cifs_fid fid;
2706 __u32 data_offset, data_count;
2712 cifs_tcon_dbg(FYI, "%s: path=%s\n", __func__, full_path);
2714 if (cap_unix(tcon->ses))
2717 oparms = (struct cifs_open_parms) {
2720 .desired_access = FILE_READ_ATTRIBUTES,
2721 .create_options = cifs_create_options(cifs_sb,
2722 OPEN_REPARSE_POINT),
2723 .disposition = FILE_OPEN,
2728 rc = CIFS_open(xid, &oparms, &oplock, NULL);
2732 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon,
2733 (void **)&io_req, (void **)&io_rsp);
2737 io_req->TotalParameterCount = 0;
2738 io_req->TotalDataCount = 0;
2739 io_req->MaxParameterCount = cpu_to_le32(2);
2740 /* BB find exact data count max from sess structure BB */
2741 io_req->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
2742 io_req->MaxSetupCount = 4;
2743 io_req->Reserved = 0;
2744 io_req->ParameterOffset = 0;
2745 io_req->DataCount = 0;
2746 io_req->DataOffset = 0;
2747 io_req->SetupCount = 4;
2748 io_req->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2749 io_req->ParameterCount = io_req->TotalParameterCount;
2750 io_req->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2751 io_req->IsFsctl = 1;
2752 io_req->IsRootFlag = 0;
2753 io_req->Fid = fid.netfid;
2754 io_req->ByteCount = 0;
2756 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)io_req,
2757 (struct smb_hdr *)io_rsp, &io_rsp_len, 0);
2761 data_offset = le32_to_cpu(io_rsp->DataOffset);
2762 data_count = le32_to_cpu(io_rsp->DataCount);
2763 if (get_bcc(&io_rsp->hdr) < 2 || data_offset > 512 ||
2764 !data_count || data_count > 2048) {
2769 end = 2 + get_bcc(&io_rsp->hdr) + (__u8 *)&io_rsp->ByteCount;
2770 start = (__u8 *)&io_rsp->hdr.Protocol + data_offset;
2776 *tag = le32_to_cpu(((struct reparse_data_buffer *)start)->ReparseTag);
2777 rsp->iov_base = io_rsp;
2778 rsp->iov_len = io_rsp_len;
2779 *rsp_buftype = CIFS_LARGE_BUFFER;
2780 CIFSSMBClose(xid, tcon, fid.netfid);
2784 cifs_buf_release(io_req);
2785 CIFSSMBClose(xid, tcon, fid.netfid);
2790 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
2795 struct smb_com_transaction_compr_ioctl_req *pSMB;
2796 struct smb_com_transaction_ioctl_rsp *pSMBr;
2798 cifs_dbg(FYI, "Set compression for %u\n", fid);
2799 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2804 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT);
2806 pSMB->TotalParameterCount = 0;
2807 pSMB->TotalDataCount = cpu_to_le32(2);
2808 pSMB->MaxParameterCount = 0;
2809 pSMB->MaxDataCount = 0;
2810 pSMB->MaxSetupCount = 4;
2812 pSMB->ParameterOffset = 0;
2813 pSMB->DataCount = cpu_to_le32(2);
2815 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req,
2816 compression_state) - 4); /* 84 */
2817 pSMB->SetupCount = 4;
2818 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2819 pSMB->ParameterCount = 0;
2820 pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION);
2821 pSMB->IsFsctl = 1; /* FSCTL */
2822 pSMB->IsRootFlag = 0;
2823 pSMB->Fid = fid; /* file handle always le */
2824 /* 3 byte pad, followed by 2 byte compress state */
2825 pSMB->ByteCount = cpu_to_le16(5);
2826 inc_rfc1001_len(pSMB, 5);
2828 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2829 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2831 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc);
2833 cifs_buf_release(pSMB);
2836 * Note: On -EAGAIN error only caller can retry on handle based calls
2837 * since file handle passed in no longer valid.
2843 #ifdef CONFIG_CIFS_POSIX
2845 #ifdef CONFIG_FS_POSIX_ACL
2847 * cifs_init_posix_acl - convert ACL from cifs to POSIX ACL format
2848 * @ace: POSIX ACL entry to store converted ACL into
2849 * @cifs_ace: ACL in cifs format
2851 * Convert an Access Control Entry from wire format to local POSIX xattr
2854 * Note that the @cifs_uid member is used to store both {g,u}id_t.
2856 static void cifs_init_posix_acl(struct posix_acl_entry *ace,
2857 struct cifs_posix_ace *cifs_ace)
2859 /* u8 cifs fields do not need le conversion */
2860 ace->e_perm = cifs_ace->cifs_e_perm;
2861 ace->e_tag = cifs_ace->cifs_e_tag;
2863 switch (ace->e_tag) {
2865 ace->e_uid = make_kuid(&init_user_ns,
2866 le64_to_cpu(cifs_ace->cifs_uid));
2869 ace->e_gid = make_kgid(&init_user_ns,
2870 le64_to_cpu(cifs_ace->cifs_uid));
2877 * cifs_to_posix_acl - copy cifs ACL format to POSIX ACL format
2878 * @acl: ACLs returned in POSIX ACL format
2879 * @src: ACLs in cifs format
2880 * @acl_type: type of POSIX ACL requested
2881 * @size_of_data_area: size of SMB we got
2883 * This function converts ACLs from cifs format to POSIX ACL format.
2884 * If @acl is NULL then the size of the buffer required to store POSIX ACLs in
2885 * their uapi format is returned.
2887 static int cifs_to_posix_acl(struct posix_acl **acl, char *src,
2888 const int acl_type, const int size_of_data_area)
2892 struct cifs_posix_ace *pACE;
2893 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
2894 struct posix_acl *kacl = NULL;
2895 struct posix_acl_entry *pa, *pe;
2897 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2900 if (acl_type == ACL_TYPE_ACCESS) {
2901 count = le16_to_cpu(cifs_acl->access_entry_count);
2902 pACE = &cifs_acl->ace_array[0];
2903 size = sizeof(struct cifs_posix_acl);
2904 size += sizeof(struct cifs_posix_ace) * count;
2905 /* check if we would go beyond end of SMB */
2906 if (size_of_data_area < size) {
2907 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
2908 size_of_data_area, size);
2911 } else if (acl_type == ACL_TYPE_DEFAULT) {
2912 count = le16_to_cpu(cifs_acl->access_entry_count);
2913 size = sizeof(struct cifs_posix_acl);
2914 size += sizeof(struct cifs_posix_ace) * count;
2915 /* skip past access ACEs to get to default ACEs */
2916 pACE = &cifs_acl->ace_array[count];
2917 count = le16_to_cpu(cifs_acl->default_entry_count);
2918 size += sizeof(struct cifs_posix_ace) * count;
2919 /* check if we would go beyond end of SMB */
2920 if (size_of_data_area < size)
2927 /* Allocate number of POSIX ACLs to store in VFS format. */
2928 kacl = posix_acl_alloc(count, GFP_NOFS);
2932 FOREACH_ACL_ENTRY(pa, kacl, pe) {
2933 cifs_init_posix_acl(pa, pACE);
2942 * cifs_init_ace - convert ACL entry from POSIX ACL to cifs format
2943 * @cifs_ace: the cifs ACL entry to store into
2944 * @local_ace: the POSIX ACL entry to convert
2946 static void cifs_init_ace(struct cifs_posix_ace *cifs_ace,
2947 const struct posix_acl_entry *local_ace)
2949 cifs_ace->cifs_e_perm = local_ace->e_perm;
2950 cifs_ace->cifs_e_tag = local_ace->e_tag;
2952 switch (local_ace->e_tag) {
2954 cifs_ace->cifs_uid =
2955 cpu_to_le64(from_kuid(&init_user_ns, local_ace->e_uid));
2958 cifs_ace->cifs_uid =
2959 cpu_to_le64(from_kgid(&init_user_ns, local_ace->e_gid));
2962 cifs_ace->cifs_uid = cpu_to_le64(-1);
2967 * posix_acl_to_cifs - convert ACLs from POSIX ACL to cifs format
2968 * @parm_data: ACLs in cifs format to conver to
2969 * @acl: ACLs in POSIX ACL format to convert from
2970 * @acl_type: the type of POSIX ACLs stored in @acl
2972 * Return: the number cifs ACL entries after conversion
2974 static __u16 posix_acl_to_cifs(char *parm_data, const struct posix_acl *acl,
2978 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
2979 const struct posix_acl_entry *pa, *pe;
2983 if ((acl == NULL) || (cifs_acl == NULL))
2986 count = acl->a_count;
2987 cifs_dbg(FYI, "setting acl with %d entries\n", count);
2990 * Note that the uapi POSIX ACL version is verified by the VFS and is
2991 * independent of the cifs ACL version. Changing the POSIX ACL version
2992 * is a uapi change and if it's changed we will pass down the POSIX ACL
2993 * version in struct posix_acl from the VFS. For now there's really
2994 * only one that all filesystems know how to deal with.
2996 cifs_acl->version = cpu_to_le16(1);
2997 if (acl_type == ACL_TYPE_ACCESS) {
2998 cifs_acl->access_entry_count = cpu_to_le16(count);
2999 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF);
3000 } else if (acl_type == ACL_TYPE_DEFAULT) {
3001 cifs_acl->default_entry_count = cpu_to_le16(count);
3002 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF);
3004 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
3007 FOREACH_ACL_ENTRY(pa, acl, pe) {
3008 cifs_init_ace(&cifs_acl->ace_array[i++], pa);
3011 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3012 rc += sizeof(struct cifs_posix_acl);
3013 /* BB add check to make sure ACL does not overflow SMB */
3018 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon,
3019 const unsigned char *searchName, struct posix_acl **acl,
3020 const int acl_type, const struct nls_table *nls_codepage,
3023 /* SMB_QUERY_POSIX_ACL */
3024 TRANSACTION2_QPI_REQ *pSMB = NULL;
3025 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3029 __u16 params, byte_count;
3031 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
3034 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3039 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3041 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3042 searchName, PATH_MAX, nls_codepage,
3044 name_len++; /* trailing null */
3046 pSMB->FileName[name_len] = 0;
3047 pSMB->FileName[name_len+1] = 0;
3049 name_len = copy_path_name(pSMB->FileName, searchName);
3052 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3053 pSMB->TotalDataCount = 0;
3054 pSMB->MaxParameterCount = cpu_to_le16(2);
3055 /* BB find exact max data count below from sess structure BB */
3056 pSMB->MaxDataCount = cpu_to_le16(4000);
3057 pSMB->MaxSetupCount = 0;
3061 pSMB->Reserved2 = 0;
3062 pSMB->ParameterOffset = cpu_to_le16(
3063 offsetof(struct smb_com_transaction2_qpi_req,
3064 InformationLevel) - 4);
3065 pSMB->DataCount = 0;
3066 pSMB->DataOffset = 0;
3067 pSMB->SetupCount = 1;
3068 pSMB->Reserved3 = 0;
3069 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3070 byte_count = params + 1 /* pad */ ;
3071 pSMB->TotalParameterCount = cpu_to_le16(params);
3072 pSMB->ParameterCount = pSMB->TotalParameterCount;
3073 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3074 pSMB->Reserved4 = 0;
3075 inc_rfc1001_len(pSMB, byte_count);
3076 pSMB->ByteCount = cpu_to_le16(byte_count);
3078 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3079 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3080 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3082 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
3084 /* decode response */
3086 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3087 /* BB also check enough total bytes returned */
3088 if (rc || get_bcc(&pSMBr->hdr) < 2)
3089 rc = -EIO; /* bad smb */
3091 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3092 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3093 rc = cifs_to_posix_acl(acl,
3094 (char *)&pSMBr->hdr.Protocol+data_offset,
3098 cifs_buf_release(pSMB);
3100 * The else branch after SendReceive() doesn't return EAGAIN so if we
3101 * allocated @acl in cifs_to_posix_acl() we are guaranteed to return
3102 * here and don't leak POSIX ACLs.
3109 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
3110 const unsigned char *fileName, const struct posix_acl *acl,
3111 const int acl_type, const struct nls_table *nls_codepage,
3114 struct smb_com_transaction2_spi_req *pSMB = NULL;
3115 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3119 int bytes_returned = 0;
3120 __u16 params, byte_count, data_count, param_offset, offset;
3122 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
3124 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3128 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3130 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3131 PATH_MAX, nls_codepage, remap);
3132 name_len++; /* trailing null */
3135 name_len = copy_path_name(pSMB->FileName, fileName);
3137 params = 6 + name_len;
3138 pSMB->MaxParameterCount = cpu_to_le16(2);
3139 /* BB find max SMB size from sess */
3140 pSMB->MaxDataCount = cpu_to_le16(1000);
3141 pSMB->MaxSetupCount = 0;
3145 pSMB->Reserved2 = 0;
3146 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3147 InformationLevel) - 4;
3148 offset = param_offset + params;
3149 parm_data = ((char *)pSMB) + sizeof(pSMB->hdr.smb_buf_length) + offset;
3150 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3152 /* convert to on the wire format for POSIX ACL */
3153 data_count = posix_acl_to_cifs(parm_data, acl, acl_type);
3155 if (data_count == 0) {
3157 goto setACLerrorExit;
3159 pSMB->DataOffset = cpu_to_le16(offset);
3160 pSMB->SetupCount = 1;
3161 pSMB->Reserved3 = 0;
3162 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3163 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3164 byte_count = 3 /* pad */ + params + data_count;
3165 pSMB->DataCount = cpu_to_le16(data_count);
3166 pSMB->TotalDataCount = pSMB->DataCount;
3167 pSMB->ParameterCount = cpu_to_le16(params);
3168 pSMB->TotalParameterCount = pSMB->ParameterCount;
3169 pSMB->Reserved4 = 0;
3170 inc_rfc1001_len(pSMB, byte_count);
3171 pSMB->ByteCount = cpu_to_le16(byte_count);
3172 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3173 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3175 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
3178 cifs_buf_release(pSMB);
3184 int cifs_do_get_acl(const unsigned int xid, struct cifs_tcon *tcon,
3185 const unsigned char *searchName, struct posix_acl **acl,
3186 const int acl_type, const struct nls_table *nls_codepage,
3192 int cifs_do_set_acl(const unsigned int xid, struct cifs_tcon *tcon,
3193 const unsigned char *fileName, const struct posix_acl *acl,
3194 const int acl_type, const struct nls_table *nls_codepage,
3199 #endif /* CONFIG_FS_POSIX_ACL */
3202 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
3203 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3206 struct smb_t2_qfi_req *pSMB = NULL;
3207 struct smb_t2_qfi_rsp *pSMBr = NULL;
3209 __u16 params, byte_count;
3211 cifs_dbg(FYI, "In GetExtAttr\n");
3216 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3221 params = 2 /* level */ + 2 /* fid */;
3222 pSMB->t2.TotalDataCount = 0;
3223 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3224 /* BB find exact max data count below from sess structure BB */
3225 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3226 pSMB->t2.MaxSetupCount = 0;
3227 pSMB->t2.Reserved = 0;
3229 pSMB->t2.Timeout = 0;
3230 pSMB->t2.Reserved2 = 0;
3231 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3233 pSMB->t2.DataCount = 0;
3234 pSMB->t2.DataOffset = 0;
3235 pSMB->t2.SetupCount = 1;
3236 pSMB->t2.Reserved3 = 0;
3237 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3238 byte_count = params + 1 /* pad */ ;
3239 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3240 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3241 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3244 inc_rfc1001_len(pSMB, byte_count);
3245 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3247 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3248 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3250 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
3252 /* decode response */
3253 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3254 /* BB also check enough total bytes returned */
3255 if (rc || get_bcc(&pSMBr->hdr) < 2)
3256 /* If rc should we check for EOPNOSUPP and
3257 disable the srvino flag? or in caller? */
3258 rc = -EIO; /* bad smb */
3260 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3261 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3262 struct file_chattr_info *pfinfo;
3265 cifs_dbg(FYI, "Invalid size ret in GetExtAttr\n");
3269 pfinfo = (struct file_chattr_info *)
3270 (data_offset + (char *) &pSMBr->hdr.Protocol);
3271 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3272 *pMask = le64_to_cpu(pfinfo->mask);
3276 cifs_buf_release(pSMB);
3278 goto GetExtAttrRetry;
3282 #endif /* CONFIG_POSIX */
3285 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3286 * all NT TRANSACTS that we init here have total parm and data under about 400
3287 * bytes (to fit in small cifs buffer size), which is the case so far, it
3288 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3289 * returned setup area) and MaxParameterCount (returned parms size) must be set
3293 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3294 const int parm_len, struct cifs_tcon *tcon,
3299 struct smb_com_ntransact_req *pSMB;
3301 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3305 *ret_buf = (void *)pSMB;
3307 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3308 pSMB->TotalDataCount = 0;
3309 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3310 pSMB->ParameterCount = pSMB->TotalParameterCount;
3311 pSMB->DataCount = pSMB->TotalDataCount;
3312 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3313 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3314 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3315 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3316 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3317 pSMB->SubCommand = cpu_to_le16(sub_command);
3322 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3323 __u32 *pparmlen, __u32 *pdatalen)
3326 __u32 data_count, data_offset, parm_count, parm_offset;
3327 struct smb_com_ntransact_rsp *pSMBr;
3336 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3338 bcc = get_bcc(&pSMBr->hdr);
3339 end_of_smb = 2 /* sizeof byte count */ + bcc +
3340 (char *)&pSMBr->ByteCount;
3342 data_offset = le32_to_cpu(pSMBr->DataOffset);
3343 data_count = le32_to_cpu(pSMBr->DataCount);
3344 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3345 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3347 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3348 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3350 /* should we also check that parm and data areas do not overlap? */
3351 if (*ppparm > end_of_smb) {
3352 cifs_dbg(FYI, "parms start after end of smb\n");
3354 } else if (parm_count + *ppparm > end_of_smb) {
3355 cifs_dbg(FYI, "parm end after end of smb\n");
3357 } else if (*ppdata > end_of_smb) {
3358 cifs_dbg(FYI, "data starts after end of smb\n");
3360 } else if (data_count + *ppdata > end_of_smb) {
3361 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3362 *ppdata, data_count, (data_count + *ppdata),
3365 } else if (parm_count + data_count > bcc) {
3366 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
3369 *pdatalen = data_count;
3370 *pparmlen = parm_count;
3374 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3376 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3377 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3381 QUERY_SEC_DESC_REQ *pSMB;
3383 struct kvec rsp_iov;
3385 cifs_dbg(FYI, "GetCifsACL\n");
3390 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3391 8 /* parm len */, tcon, (void **) &pSMB);
3395 pSMB->MaxParameterCount = cpu_to_le32(4);
3396 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3397 pSMB->MaxSetupCount = 0;
3398 pSMB->Fid = fid; /* file handle always le */
3399 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3401 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3402 inc_rfc1001_len(pSMB, 11);
3403 iov[0].iov_base = (char *)pSMB;
3404 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3406 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3408 cifs_small_buf_release(pSMB);
3409 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3411 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
3412 } else { /* decode response */
3416 struct smb_com_ntransact_rsp *pSMBr;
3419 /* validate_nttransact */
3420 rc = validate_ntransact(rsp_iov.iov_base, (char **)&parm,
3421 &pdata, &parm_len, pbuflen);
3424 pSMBr = (struct smb_com_ntransact_rsp *)rsp_iov.iov_base;
3426 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3427 pSMBr, parm, *acl_inf);
3429 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3430 rc = -EIO; /* bad smb */
3435 /* BB check that data area is minimum length and as big as acl_len */
3437 acl_len = le32_to_cpu(*parm);
3438 if (acl_len != *pbuflen) {
3439 cifs_dbg(VFS, "acl length %d does not match %d\n",
3441 if (*pbuflen > acl_len)
3445 /* check if buffer is big enough for the acl
3446 header followed by the smallest SID */
3447 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3448 (*pbuflen >= 64 * 1024)) {
3449 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
3453 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
3454 if (*acl_inf == NULL) {
3461 free_rsp_buf(buf_type, rsp_iov.iov_base);
3466 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3467 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3469 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3471 int bytes_returned = 0;
3472 SET_SEC_DESC_REQ *pSMB = NULL;
3476 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
3480 pSMB->MaxSetupCount = 0;
3484 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3485 data_count = acllen;
3486 data_offset = param_offset + param_count;
3487 byte_count = 3 /* pad */ + param_count;
3489 pSMB->DataCount = cpu_to_le32(data_count);
3490 pSMB->TotalDataCount = pSMB->DataCount;
3491 pSMB->MaxParameterCount = cpu_to_le32(4);
3492 pSMB->MaxDataCount = cpu_to_le32(16384);
3493 pSMB->ParameterCount = cpu_to_le32(param_count);
3494 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3495 pSMB->TotalParameterCount = pSMB->ParameterCount;
3496 pSMB->DataOffset = cpu_to_le32(data_offset);
3497 pSMB->SetupCount = 0;
3498 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3499 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3501 pSMB->Fid = fid; /* file handle always le */
3502 pSMB->Reserved2 = 0;
3503 pSMB->AclFlags = cpu_to_le32(aclflag);
3505 if (pntsd && acllen) {
3506 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
3507 data_offset, pntsd, acllen);
3508 inc_rfc1001_len(pSMB, byte_count + data_count);
3510 inc_rfc1001_len(pSMB, byte_count);
3512 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3513 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3515 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3516 bytes_returned, rc);
3518 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
3519 cifs_buf_release(pSMB);
3522 goto setCifsAclRetry;
3528 /* Legacy Query Path Information call for lookup to old servers such
3531 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
3532 const char *search_name, FILE_ALL_INFO *data,
3533 const struct nls_table *nls_codepage, int remap)
3535 QUERY_INFORMATION_REQ *pSMB;
3536 QUERY_INFORMATION_RSP *pSMBr;
3541 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
3543 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3548 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3550 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3551 search_name, PATH_MAX, nls_codepage,
3553 name_len++; /* trailing null */
3556 name_len = copy_path_name(pSMB->FileName, search_name);
3558 pSMB->BufferFormat = 0x04;
3559 name_len++; /* account for buffer type byte */
3560 inc_rfc1001_len(pSMB, (__u16)name_len);
3561 pSMB->ByteCount = cpu_to_le16(name_len);
3563 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3564 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3566 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
3568 struct timespec64 ts;
3569 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3571 /* decode response */
3572 /* BB FIXME - add time zone adjustment BB */
3573 memset(data, 0, sizeof(FILE_ALL_INFO));
3576 /* decode time fields */
3577 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3578 data->LastWriteTime = data->ChangeTime;
3579 data->LastAccessTime = 0;
3580 data->AllocationSize =
3581 cpu_to_le64(le32_to_cpu(pSMBr->size));
3582 data->EndOfFile = data->AllocationSize;
3584 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3586 rc = -EIO; /* bad buffer passed in */
3588 cifs_buf_release(pSMB);
3597 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
3598 u16 netfid, FILE_ALL_INFO *pFindData)
3600 struct smb_t2_qfi_req *pSMB = NULL;
3601 struct smb_t2_qfi_rsp *pSMBr = NULL;
3604 __u16 params, byte_count;
3607 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3612 params = 2 /* level */ + 2 /* fid */;
3613 pSMB->t2.TotalDataCount = 0;
3614 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3615 /* BB find exact max data count below from sess structure BB */
3616 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3617 pSMB->t2.MaxSetupCount = 0;
3618 pSMB->t2.Reserved = 0;
3620 pSMB->t2.Timeout = 0;
3621 pSMB->t2.Reserved2 = 0;
3622 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3624 pSMB->t2.DataCount = 0;
3625 pSMB->t2.DataOffset = 0;
3626 pSMB->t2.SetupCount = 1;
3627 pSMB->t2.Reserved3 = 0;
3628 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3629 byte_count = params + 1 /* pad */ ;
3630 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3631 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3632 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3635 inc_rfc1001_len(pSMB, byte_count);
3636 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3638 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3639 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3641 cifs_dbg(FYI, "Send error in QFileInfo = %d\n", rc);
3642 } else { /* decode response */
3643 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3645 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3647 else if (get_bcc(&pSMBr->hdr) < 40)
3648 rc = -EIO; /* bad smb */
3649 else if (pFindData) {
3650 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3651 memcpy((char *) pFindData,
3652 (char *) &pSMBr->hdr.Protocol +
3653 data_offset, sizeof(FILE_ALL_INFO));
3657 cifs_buf_release(pSMB);
3659 goto QFileInfoRetry;
3665 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
3666 const char *search_name, FILE_ALL_INFO *data,
3667 int legacy /* old style infolevel */,
3668 const struct nls_table *nls_codepage, int remap)
3670 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3671 TRANSACTION2_QPI_REQ *pSMB = NULL;
3672 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3676 __u16 params, byte_count;
3678 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
3680 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3685 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3687 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
3688 PATH_MAX, nls_codepage, remap);
3689 name_len++; /* trailing null */
3692 name_len = copy_path_name(pSMB->FileName, search_name);
3695 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3696 pSMB->TotalDataCount = 0;
3697 pSMB->MaxParameterCount = cpu_to_le16(2);
3698 /* BB find exact max SMB PDU from sess structure BB */
3699 pSMB->MaxDataCount = cpu_to_le16(4000);
3700 pSMB->MaxSetupCount = 0;
3704 pSMB->Reserved2 = 0;
3705 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3706 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3707 pSMB->DataCount = 0;
3708 pSMB->DataOffset = 0;
3709 pSMB->SetupCount = 1;
3710 pSMB->Reserved3 = 0;
3711 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3712 byte_count = params + 1 /* pad */ ;
3713 pSMB->TotalParameterCount = cpu_to_le16(params);
3714 pSMB->ParameterCount = pSMB->TotalParameterCount;
3716 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3718 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3719 pSMB->Reserved4 = 0;
3720 inc_rfc1001_len(pSMB, byte_count);
3721 pSMB->ByteCount = cpu_to_le16(byte_count);
3723 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3724 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3726 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
3727 } else { /* decode response */
3728 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3730 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3732 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
3733 rc = -EIO; /* bad smb */
3734 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
3735 rc = -EIO; /* 24 or 26 expected but we do not read
3739 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3742 * On legacy responses we do not read the last field,
3743 * EAsize, fortunately since it varies by subdialect and
3744 * also note it differs on Set vs Get, ie two bytes or 4
3745 * bytes depending but we don't care here.
3748 size = sizeof(FILE_INFO_STANDARD);
3750 size = sizeof(FILE_ALL_INFO);
3751 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
3756 cifs_buf_release(pSMB);
3758 goto QPathInfoRetry;
3764 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
3765 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
3767 struct smb_t2_qfi_req *pSMB = NULL;
3768 struct smb_t2_qfi_rsp *pSMBr = NULL;
3771 __u16 params, byte_count;
3774 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3779 params = 2 /* level */ + 2 /* fid */;
3780 pSMB->t2.TotalDataCount = 0;
3781 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3782 /* BB find exact max data count below from sess structure BB */
3783 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3784 pSMB->t2.MaxSetupCount = 0;
3785 pSMB->t2.Reserved = 0;
3787 pSMB->t2.Timeout = 0;
3788 pSMB->t2.Reserved2 = 0;
3789 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3791 pSMB->t2.DataCount = 0;
3792 pSMB->t2.DataOffset = 0;
3793 pSMB->t2.SetupCount = 1;
3794 pSMB->t2.Reserved3 = 0;
3795 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3796 byte_count = params + 1 /* pad */ ;
3797 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3798 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3799 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3802 inc_rfc1001_len(pSMB, byte_count);
3803 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3805 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3806 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3808 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d\n", rc);
3809 } else { /* decode response */
3810 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3812 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
3813 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
3814 rc = -EIO; /* bad smb */
3816 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3817 memcpy((char *) pFindData,
3818 (char *) &pSMBr->hdr.Protocol +
3820 sizeof(FILE_UNIX_BASIC_INFO));
3824 cifs_buf_release(pSMB);
3826 goto UnixQFileInfoRetry;
3832 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
3833 const unsigned char *searchName,
3834 FILE_UNIX_BASIC_INFO *pFindData,
3835 const struct nls_table *nls_codepage, int remap)
3837 /* SMB_QUERY_FILE_UNIX_BASIC */
3838 TRANSACTION2_QPI_REQ *pSMB = NULL;
3839 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3841 int bytes_returned = 0;
3843 __u16 params, byte_count;
3845 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
3847 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3852 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3854 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
3855 PATH_MAX, nls_codepage, remap);
3856 name_len++; /* trailing null */
3859 name_len = copy_path_name(pSMB->FileName, searchName);
3862 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3863 pSMB->TotalDataCount = 0;
3864 pSMB->MaxParameterCount = cpu_to_le16(2);
3865 /* BB find exact max SMB PDU from sess structure BB */
3866 pSMB->MaxDataCount = cpu_to_le16(4000);
3867 pSMB->MaxSetupCount = 0;
3871 pSMB->Reserved2 = 0;
3872 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3873 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3874 pSMB->DataCount = 0;
3875 pSMB->DataOffset = 0;
3876 pSMB->SetupCount = 1;
3877 pSMB->Reserved3 = 0;
3878 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3879 byte_count = params + 1 /* pad */ ;
3880 pSMB->TotalParameterCount = cpu_to_le16(params);
3881 pSMB->ParameterCount = pSMB->TotalParameterCount;
3882 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3883 pSMB->Reserved4 = 0;
3884 inc_rfc1001_len(pSMB, byte_count);
3885 pSMB->ByteCount = cpu_to_le16(byte_count);
3887 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3888 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3890 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d\n", rc);
3891 } else { /* decode response */
3892 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3894 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
3895 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
3896 rc = -EIO; /* bad smb */
3898 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3899 memcpy((char *) pFindData,
3900 (char *) &pSMBr->hdr.Protocol +
3902 sizeof(FILE_UNIX_BASIC_INFO));
3905 cifs_buf_release(pSMB);
3907 goto UnixQPathInfoRetry;
3912 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3914 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
3915 const char *searchName, struct cifs_sb_info *cifs_sb,
3916 __u16 *pnetfid, __u16 search_flags,
3917 struct cifs_search_info *psrch_inf, bool msearch)
3919 /* level 257 SMB_ */
3920 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3921 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3922 T2_FFIRST_RSP_PARMS *parms;
3923 struct nls_table *nls_codepage;
3925 __u16 params, byte_count;
3926 int bytes_returned = 0;
3927 int name_len, remap;
3930 cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
3933 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3938 nls_codepage = cifs_sb->local_nls;
3939 remap = cifs_remap(cifs_sb);
3941 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3943 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
3944 PATH_MAX, nls_codepage, remap);
3945 /* We can not add the asterik earlier in case
3946 it got remapped to 0xF03A as if it were part of the
3947 directory name instead of a wildcard */
3950 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
3951 pSMB->FileName[name_len+1] = 0;
3952 pSMB->FileName[name_len+2] = '*';
3953 pSMB->FileName[name_len+3] = 0;
3954 name_len += 4; /* now the trailing null */
3955 /* null terminate just in case */
3956 pSMB->FileName[name_len] = 0;
3957 pSMB->FileName[name_len+1] = 0;
3961 name_len = copy_path_name(pSMB->FileName, searchName);
3963 if (WARN_ON_ONCE(name_len > PATH_MAX-2))
3964 name_len = PATH_MAX-2;
3965 /* overwrite nul byte */
3966 pSMB->FileName[name_len-1] = CIFS_DIR_SEP(cifs_sb);
3967 pSMB->FileName[name_len] = '*';
3968 pSMB->FileName[name_len+1] = 0;
3973 params = 12 + name_len /* includes null */ ;
3974 pSMB->TotalDataCount = 0; /* no EAs */
3975 pSMB->MaxParameterCount = cpu_to_le16(10);
3976 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
3977 pSMB->MaxSetupCount = 0;
3981 pSMB->Reserved2 = 0;
3982 byte_count = params + 1 /* pad */ ;
3983 pSMB->TotalParameterCount = cpu_to_le16(params);
3984 pSMB->ParameterCount = pSMB->TotalParameterCount;
3985 pSMB->ParameterOffset = cpu_to_le16(
3986 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3988 pSMB->DataCount = 0;
3989 pSMB->DataOffset = 0;
3990 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
3991 pSMB->Reserved3 = 0;
3992 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3993 pSMB->SearchAttributes =
3994 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3996 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3997 pSMB->SearchFlags = cpu_to_le16(search_flags);
3998 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4000 /* BB what should we set StorageType to? Does it matter? BB */
4001 pSMB->SearchStorageType = 0;
4002 inc_rfc1001_len(pSMB, byte_count);
4003 pSMB->ByteCount = cpu_to_le16(byte_count);
4005 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4006 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4007 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
4011 * BB: add logic to retry regular search if Unix search rejected
4012 * unexpectedly by server.
4014 /* BB: add code to handle unsupported level rc */
4015 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
4016 cifs_buf_release(pSMB);
4018 * BB: eventually could optimize out free and realloc of buf for
4022 goto findFirstRetry;
4025 /* decode response */
4026 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4028 cifs_buf_release(pSMB);
4032 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE);
4033 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4034 psrch_inf->smallBuf = false;
4035 psrch_inf->srch_entries_start = (char *)&pSMBr->hdr.Protocol +
4036 le16_to_cpu(pSMBr->t2.DataOffset);
4038 parms = (T2_FFIRST_RSP_PARMS *)((char *)&pSMBr->hdr.Protocol +
4039 le16_to_cpu(pSMBr->t2.ParameterOffset));
4040 psrch_inf->endOfSearch = !!parms->EndofSearch;
4042 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
4043 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4044 psrch_inf->entries_in_buffer;
4045 lnoff = le16_to_cpu(parms->LastNameOffset);
4046 if (CIFSMaxBufSize < lnoff) {
4047 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4048 psrch_inf->last_entry = NULL;
4050 psrch_inf->last_entry = psrch_inf->srch_entries_start + lnoff;
4052 *pnetfid = parms->SearchHandle;
4057 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4058 __u16 searchHandle, __u16 search_flags,
4059 struct cifs_search_info *psrch_inf)
4061 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4062 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4063 T2_FNEXT_RSP_PARMS *parms;
4064 unsigned int name_len;
4066 __u16 params, byte_count;
4067 char *response_data;
4071 cifs_dbg(FYI, "In FindNext\n");
4073 if (psrch_inf->endOfSearch)
4076 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4081 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4083 pSMB->TotalDataCount = 0; /* no EAs */
4084 pSMB->MaxParameterCount = cpu_to_le16(8);
4085 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4086 pSMB->MaxSetupCount = 0;
4090 pSMB->Reserved2 = 0;
4091 pSMB->ParameterOffset = cpu_to_le16(
4092 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4093 pSMB->DataCount = 0;
4094 pSMB->DataOffset = 0;
4095 pSMB->SetupCount = 1;
4096 pSMB->Reserved3 = 0;
4097 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4098 pSMB->SearchHandle = searchHandle; /* always kept as le */
4100 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4101 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4102 pSMB->ResumeKey = psrch_inf->resume_key;
4103 pSMB->SearchFlags = cpu_to_le16(search_flags);
4105 name_len = psrch_inf->resume_name_len;
4107 if (name_len < PATH_MAX) {
4108 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4109 byte_count += name_len;
4110 /* 14 byte parm len above enough for 2 byte null terminator */
4111 pSMB->ResumeFileName[name_len] = 0;
4112 pSMB->ResumeFileName[name_len+1] = 0;
4114 cifs_buf_release(pSMB);
4117 byte_count = params + 1 /* pad */ ;
4118 pSMB->TotalParameterCount = cpu_to_le16(params);
4119 pSMB->ParameterCount = pSMB->TotalParameterCount;
4120 inc_rfc1001_len(pSMB, byte_count);
4121 pSMB->ByteCount = cpu_to_le16(byte_count);
4123 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4124 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4125 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
4128 cifs_buf_release(pSMB);
4130 psrch_inf->endOfSearch = true;
4131 rc = 0; /* search probably was closed at end of search*/
4133 cifs_dbg(FYI, "FindNext returned = %d\n", rc);
4138 /* decode response */
4139 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4141 cifs_buf_release(pSMB);
4144 /* BB fixme add lock for file (srch_info) struct here */
4145 psrch_inf->unicode = !!(pSMBr->hdr.Flags2 & SMBFLG2_UNICODE);
4146 response_data = (char *)&pSMBr->hdr.Protocol +
4147 le16_to_cpu(pSMBr->t2.ParameterOffset);
4148 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4149 response_data = (char *)&pSMBr->hdr.Protocol +
4150 le16_to_cpu(pSMBr->t2.DataOffset);
4152 if (psrch_inf->smallBuf)
4153 cifs_small_buf_release(psrch_inf->ntwrk_buf_start);
4155 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4157 psrch_inf->srch_entries_start = response_data;
4158 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4159 psrch_inf->smallBuf = false;
4160 psrch_inf->endOfSearch = !!parms->EndofSearch;
4161 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
4162 psrch_inf->index_of_last_entry += psrch_inf->entries_in_buffer;
4163 lnoff = le16_to_cpu(parms->LastNameOffset);
4164 if (CIFSMaxBufSize < lnoff) {
4165 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4166 psrch_inf->last_entry = NULL;
4168 psrch_inf->last_entry =
4169 psrch_inf->srch_entries_start + lnoff;
4171 /* BB fixme add unlock here */
4174 * BB: On error, should we leave previous search buf
4175 * (and count and last entry fields) intact or free the previous one?
4177 * Note: On -EAGAIN error only caller can retry on handle based calls
4178 * since file handle passed in no longer valid.
4184 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
4185 const __u16 searchHandle)
4188 FINDCLOSE_REQ *pSMB = NULL;
4190 cifs_dbg(FYI, "In CIFSSMBFindClose\n");
4191 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4193 /* no sense returning error if session restarted
4194 as file handle has been closed */
4200 pSMB->FileID = searchHandle;
4201 pSMB->ByteCount = 0;
4202 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4203 cifs_small_buf_release(pSMB);
4205 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
4207 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
4209 /* Since session is dead, search handle closed on server already */
4217 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
4218 const char *search_name, __u64 *inode_number,
4219 const struct nls_table *nls_codepage, int remap)
4222 TRANSACTION2_QPI_REQ *pSMB = NULL;
4223 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4224 int name_len, bytes_returned;
4225 __u16 params, byte_count;
4227 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
4231 GetInodeNumberRetry:
4232 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4237 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4239 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4240 search_name, PATH_MAX, nls_codepage,
4242 name_len++; /* trailing null */
4245 name_len = copy_path_name(pSMB->FileName, search_name);
4248 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4249 pSMB->TotalDataCount = 0;
4250 pSMB->MaxParameterCount = cpu_to_le16(2);
4251 /* BB find exact max data count below from sess structure BB */
4252 pSMB->MaxDataCount = cpu_to_le16(4000);
4253 pSMB->MaxSetupCount = 0;
4257 pSMB->Reserved2 = 0;
4258 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4259 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4260 pSMB->DataCount = 0;
4261 pSMB->DataOffset = 0;
4262 pSMB->SetupCount = 1;
4263 pSMB->Reserved3 = 0;
4264 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4265 byte_count = params + 1 /* pad */ ;
4266 pSMB->TotalParameterCount = cpu_to_le16(params);
4267 pSMB->ParameterCount = pSMB->TotalParameterCount;
4268 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4269 pSMB->Reserved4 = 0;
4270 inc_rfc1001_len(pSMB, byte_count);
4271 pSMB->ByteCount = cpu_to_le16(byte_count);
4273 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4274 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4276 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
4278 /* decode response */
4279 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4280 /* BB also check enough total bytes returned */
4281 if (rc || get_bcc(&pSMBr->hdr) < 2)
4282 /* If rc should we check for EOPNOSUPP and
4283 disable the srvino flag? or in caller? */
4284 rc = -EIO; /* bad smb */
4286 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4287 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4288 struct file_internal_info *pfinfo;
4289 /* BB Do we need a cast or hash here ? */
4291 cifs_dbg(FYI, "Invalid size ret in QryIntrnlInf\n");
4293 goto GetInodeNumOut;
4295 pfinfo = (struct file_internal_info *)
4296 (data_offset + (char *) &pSMBr->hdr.Protocol);
4297 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4301 cifs_buf_release(pSMB);
4303 goto GetInodeNumberRetry;
4308 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
4309 const char *search_name, struct dfs_info3_param **target_nodes,
4310 unsigned int *num_of_nodes,
4311 const struct nls_table *nls_codepage, int remap)
4313 /* TRANS2_GET_DFS_REFERRAL */
4314 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4315 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4319 __u16 params, byte_count;
4321 *target_nodes = NULL;
4323 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
4324 if (ses == NULL || ses->tcon_ipc == NULL)
4329 * Use smb_init_no_reconnect() instead of smb_init() as
4330 * CIFSGetDFSRefer() may be called from cifs_reconnect_tcon() and thus
4331 * causing an infinite recursion.
4333 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, ses->tcon_ipc,
4334 (void **)&pSMB, (void **)&pSMBr);
4338 /* server pointer checked in called function,
4339 but should never be null here anyway */
4340 pSMB->hdr.Mid = get_next_mid(ses->server);
4341 pSMB->hdr.Tid = ses->tcon_ipc->tid;
4342 pSMB->hdr.Uid = ses->Suid;
4343 if (ses->capabilities & CAP_STATUS32)
4344 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4345 if (ses->capabilities & CAP_DFS)
4346 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4348 if (ses->capabilities & CAP_UNICODE) {
4349 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4351 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4352 search_name, PATH_MAX, nls_codepage,
4354 name_len++; /* trailing null */
4356 } else { /* BB improve the check for buffer overruns BB */
4357 name_len = copy_path_name(pSMB->RequestFileName, search_name);
4360 if (ses->server->sign)
4361 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4363 pSMB->hdr.Uid = ses->Suid;
4365 params = 2 /* level */ + name_len /*includes null */ ;
4366 pSMB->TotalDataCount = 0;
4367 pSMB->DataCount = 0;
4368 pSMB->DataOffset = 0;
4369 pSMB->MaxParameterCount = 0;
4370 /* BB find exact max SMB PDU from sess structure BB */
4371 pSMB->MaxDataCount = cpu_to_le16(4000);
4372 pSMB->MaxSetupCount = 0;
4376 pSMB->Reserved2 = 0;
4377 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4378 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4379 pSMB->SetupCount = 1;
4380 pSMB->Reserved3 = 0;
4381 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4382 byte_count = params + 3 /* pad */ ;
4383 pSMB->ParameterCount = cpu_to_le16(params);
4384 pSMB->TotalParameterCount = pSMB->ParameterCount;
4385 pSMB->MaxReferralLevel = cpu_to_le16(3);
4386 inc_rfc1001_len(pSMB, byte_count);
4387 pSMB->ByteCount = cpu_to_le16(byte_count);
4389 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4390 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4392 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
4395 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4397 /* BB Also check if enough total bytes returned? */
4398 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4399 rc = -EIO; /* bad smb */
4403 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4404 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
4406 /* parse returned result into more usable form */
4407 rc = parse_dfs_referrals(&pSMBr->dfs_data,
4408 le16_to_cpu(pSMBr->t2.DataCount),
4409 num_of_nodes, target_nodes, nls_codepage,
4411 (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) != 0);
4414 cifs_buf_release(pSMB);
4422 /* Query File System Info such as free space to old servers such as Win 9x */
4424 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4425 struct kstatfs *FSData)
4427 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4428 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4429 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4430 FILE_SYSTEM_ALLOC_INFO *response_data;
4432 int bytes_returned = 0;
4433 __u16 params, byte_count;
4435 cifs_dbg(FYI, "OldQFSInfo\n");
4437 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4442 params = 2; /* level */
4443 pSMB->TotalDataCount = 0;
4444 pSMB->MaxParameterCount = cpu_to_le16(2);
4445 pSMB->MaxDataCount = cpu_to_le16(1000);
4446 pSMB->MaxSetupCount = 0;
4450 pSMB->Reserved2 = 0;
4451 byte_count = params + 1 /* pad */ ;
4452 pSMB->TotalParameterCount = cpu_to_le16(params);
4453 pSMB->ParameterCount = pSMB->TotalParameterCount;
4454 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4455 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4456 pSMB->DataCount = 0;
4457 pSMB->DataOffset = 0;
4458 pSMB->SetupCount = 1;
4459 pSMB->Reserved3 = 0;
4460 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4461 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4462 inc_rfc1001_len(pSMB, byte_count);
4463 pSMB->ByteCount = cpu_to_le16(byte_count);
4465 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4466 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4468 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4469 } else { /* decode response */
4470 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4472 if (rc || get_bcc(&pSMBr->hdr) < 18)
4473 rc = -EIO; /* bad smb */
4475 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4476 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n",
4477 get_bcc(&pSMBr->hdr), data_offset);
4479 response_data = (FILE_SYSTEM_ALLOC_INFO *)
4480 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4482 le16_to_cpu(response_data->BytesPerSector) *
4483 le32_to_cpu(response_data->
4484 SectorsPerAllocationUnit);
4486 * much prefer larger but if server doesn't report
4487 * a valid size than 4K is a reasonable minimum
4489 if (FSData->f_bsize < 512)
4490 FSData->f_bsize = 4096;
4493 le32_to_cpu(response_data->TotalAllocationUnits);
4494 FSData->f_bfree = FSData->f_bavail =
4495 le32_to_cpu(response_data->FreeAllocationUnits);
4496 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4497 (unsigned long long)FSData->f_blocks,
4498 (unsigned long long)FSData->f_bfree,
4502 cifs_buf_release(pSMB);
4505 goto oldQFSInfoRetry;
4511 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4512 struct kstatfs *FSData)
4514 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4515 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4516 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4517 FILE_SYSTEM_INFO *response_data;
4519 int bytes_returned = 0;
4520 __u16 params, byte_count;
4522 cifs_dbg(FYI, "In QFSInfo\n");
4524 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4529 params = 2; /* level */
4530 pSMB->TotalDataCount = 0;
4531 pSMB->MaxParameterCount = cpu_to_le16(2);
4532 pSMB->MaxDataCount = cpu_to_le16(1000);
4533 pSMB->MaxSetupCount = 0;
4537 pSMB->Reserved2 = 0;
4538 byte_count = params + 1 /* pad */ ;
4539 pSMB->TotalParameterCount = cpu_to_le16(params);
4540 pSMB->ParameterCount = pSMB->TotalParameterCount;
4541 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4542 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4543 pSMB->DataCount = 0;
4544 pSMB->DataOffset = 0;
4545 pSMB->SetupCount = 1;
4546 pSMB->Reserved3 = 0;
4547 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4548 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4549 inc_rfc1001_len(pSMB, byte_count);
4550 pSMB->ByteCount = cpu_to_le16(byte_count);
4552 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4553 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4555 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4556 } else { /* decode response */
4557 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4559 if (rc || get_bcc(&pSMBr->hdr) < 24)
4560 rc = -EIO; /* bad smb */
4562 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4566 *) (((char *) &pSMBr->hdr.Protocol) +
4569 le32_to_cpu(response_data->BytesPerSector) *
4570 le32_to_cpu(response_data->
4571 SectorsPerAllocationUnit);
4573 * much prefer larger but if server doesn't report
4574 * a valid size than 4K is a reasonable minimum
4576 if (FSData->f_bsize < 512)
4577 FSData->f_bsize = 4096;
4580 le64_to_cpu(response_data->TotalAllocationUnits);
4581 FSData->f_bfree = FSData->f_bavail =
4582 le64_to_cpu(response_data->FreeAllocationUnits);
4583 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4584 (unsigned long long)FSData->f_blocks,
4585 (unsigned long long)FSData->f_bfree,
4589 cifs_buf_release(pSMB);
4598 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
4600 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
4601 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4602 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4603 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4605 int bytes_returned = 0;
4606 __u16 params, byte_count;
4608 cifs_dbg(FYI, "In QFSAttributeInfo\n");
4610 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4615 params = 2; /* level */
4616 pSMB->TotalDataCount = 0;
4617 pSMB->MaxParameterCount = cpu_to_le16(2);
4618 /* BB find exact max SMB PDU from sess structure BB */
4619 pSMB->MaxDataCount = cpu_to_le16(1000);
4620 pSMB->MaxSetupCount = 0;
4624 pSMB->Reserved2 = 0;
4625 byte_count = params + 1 /* pad */ ;
4626 pSMB->TotalParameterCount = cpu_to_le16(params);
4627 pSMB->ParameterCount = pSMB->TotalParameterCount;
4628 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4629 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4630 pSMB->DataCount = 0;
4631 pSMB->DataOffset = 0;
4632 pSMB->SetupCount = 1;
4633 pSMB->Reserved3 = 0;
4634 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4635 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4636 inc_rfc1001_len(pSMB, byte_count);
4637 pSMB->ByteCount = cpu_to_le16(byte_count);
4639 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4640 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4642 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
4643 } else { /* decode response */
4644 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4646 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4647 /* BB also check if enough bytes returned */
4648 rc = -EIO; /* bad smb */
4650 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4652 (FILE_SYSTEM_ATTRIBUTE_INFO
4653 *) (((char *) &pSMBr->hdr.Protocol) +
4655 memcpy(&tcon->fsAttrInfo, response_data,
4656 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4659 cifs_buf_release(pSMB);
4662 goto QFSAttributeRetry;
4668 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
4670 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4671 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4672 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4673 FILE_SYSTEM_DEVICE_INFO *response_data;
4675 int bytes_returned = 0;
4676 __u16 params, byte_count;
4678 cifs_dbg(FYI, "In QFSDeviceInfo\n");
4680 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4685 params = 2; /* level */
4686 pSMB->TotalDataCount = 0;
4687 pSMB->MaxParameterCount = cpu_to_le16(2);
4688 /* BB find exact max SMB PDU from sess structure BB */
4689 pSMB->MaxDataCount = cpu_to_le16(1000);
4690 pSMB->MaxSetupCount = 0;
4694 pSMB->Reserved2 = 0;
4695 byte_count = params + 1 /* pad */ ;
4696 pSMB->TotalParameterCount = cpu_to_le16(params);
4697 pSMB->ParameterCount = pSMB->TotalParameterCount;
4698 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4699 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4701 pSMB->DataCount = 0;
4702 pSMB->DataOffset = 0;
4703 pSMB->SetupCount = 1;
4704 pSMB->Reserved3 = 0;
4705 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4706 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4707 inc_rfc1001_len(pSMB, byte_count);
4708 pSMB->ByteCount = cpu_to_le16(byte_count);
4710 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4711 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4713 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
4714 } else { /* decode response */
4715 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4717 if (rc || get_bcc(&pSMBr->hdr) <
4718 sizeof(FILE_SYSTEM_DEVICE_INFO))
4719 rc = -EIO; /* bad smb */
4721 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4723 (FILE_SYSTEM_DEVICE_INFO *)
4724 (((char *) &pSMBr->hdr.Protocol) +
4726 memcpy(&tcon->fsDevInfo, response_data,
4727 sizeof(FILE_SYSTEM_DEVICE_INFO));
4730 cifs_buf_release(pSMB);
4733 goto QFSDeviceRetry;
4739 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
4741 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
4742 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4743 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4744 FILE_SYSTEM_UNIX_INFO *response_data;
4746 int bytes_returned = 0;
4747 __u16 params, byte_count;
4749 cifs_dbg(FYI, "In QFSUnixInfo\n");
4751 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
4752 (void **) &pSMB, (void **) &pSMBr);
4756 params = 2; /* level */
4757 pSMB->TotalDataCount = 0;
4758 pSMB->DataCount = 0;
4759 pSMB->DataOffset = 0;
4760 pSMB->MaxParameterCount = cpu_to_le16(2);
4761 /* BB find exact max SMB PDU from sess structure BB */
4762 pSMB->MaxDataCount = cpu_to_le16(100);
4763 pSMB->MaxSetupCount = 0;
4767 pSMB->Reserved2 = 0;
4768 byte_count = params + 1 /* pad */ ;
4769 pSMB->ParameterCount = cpu_to_le16(params);
4770 pSMB->TotalParameterCount = pSMB->ParameterCount;
4771 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4772 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4773 pSMB->SetupCount = 1;
4774 pSMB->Reserved3 = 0;
4775 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4776 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4777 inc_rfc1001_len(pSMB, byte_count);
4778 pSMB->ByteCount = cpu_to_le16(byte_count);
4780 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4781 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4783 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
4784 } else { /* decode response */
4785 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4787 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4788 rc = -EIO; /* bad smb */
4790 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4792 (FILE_SYSTEM_UNIX_INFO
4793 *) (((char *) &pSMBr->hdr.Protocol) +
4795 memcpy(&tcon->fsUnixInfo, response_data,
4796 sizeof(FILE_SYSTEM_UNIX_INFO));
4799 cifs_buf_release(pSMB);
4809 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
4811 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
4812 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4813 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4815 int bytes_returned = 0;
4816 __u16 params, param_offset, offset, byte_count;
4818 cifs_dbg(FYI, "In SETFSUnixInfo\n");
4820 /* BB switch to small buf init to save memory */
4821 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
4822 (void **) &pSMB, (void **) &pSMBr);
4826 params = 4; /* 2 bytes zero followed by info level. */
4827 pSMB->MaxSetupCount = 0;
4831 pSMB->Reserved2 = 0;
4832 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4834 offset = param_offset + params;
4836 pSMB->MaxParameterCount = cpu_to_le16(4);
4837 /* BB find exact max SMB PDU from sess structure BB */
4838 pSMB->MaxDataCount = cpu_to_le16(100);
4839 pSMB->SetupCount = 1;
4840 pSMB->Reserved3 = 0;
4841 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4842 byte_count = 1 /* pad */ + params + 12;
4844 pSMB->DataCount = cpu_to_le16(12);
4845 pSMB->ParameterCount = cpu_to_le16(params);
4846 pSMB->TotalDataCount = pSMB->DataCount;
4847 pSMB->TotalParameterCount = pSMB->ParameterCount;
4848 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4849 pSMB->DataOffset = cpu_to_le16(offset);
4853 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4856 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4857 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4858 pSMB->ClientUnixCap = cpu_to_le64(cap);
4860 inc_rfc1001_len(pSMB, byte_count);
4861 pSMB->ByteCount = cpu_to_le16(byte_count);
4863 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4864 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4866 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
4867 } else { /* decode response */
4868 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4870 rc = -EIO; /* bad smb */
4872 cifs_buf_release(pSMB);
4875 goto SETFSUnixRetry;
4883 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
4884 struct kstatfs *FSData)
4886 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
4887 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4888 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4889 FILE_SYSTEM_POSIX_INFO *response_data;
4891 int bytes_returned = 0;
4892 __u16 params, byte_count;
4894 cifs_dbg(FYI, "In QFSPosixInfo\n");
4896 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4901 params = 2; /* level */
4902 pSMB->TotalDataCount = 0;
4903 pSMB->DataCount = 0;
4904 pSMB->DataOffset = 0;
4905 pSMB->MaxParameterCount = cpu_to_le16(2);
4906 /* BB find exact max SMB PDU from sess structure BB */
4907 pSMB->MaxDataCount = cpu_to_le16(100);
4908 pSMB->MaxSetupCount = 0;
4912 pSMB->Reserved2 = 0;
4913 byte_count = params + 1 /* pad */ ;
4914 pSMB->ParameterCount = cpu_to_le16(params);
4915 pSMB->TotalParameterCount = pSMB->ParameterCount;
4916 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4917 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4918 pSMB->SetupCount = 1;
4919 pSMB->Reserved3 = 0;
4920 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4921 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4922 inc_rfc1001_len(pSMB, byte_count);
4923 pSMB->ByteCount = cpu_to_le16(byte_count);
4925 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4926 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4928 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
4929 } else { /* decode response */
4930 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4932 if (rc || get_bcc(&pSMBr->hdr) < 13) {
4933 rc = -EIO; /* bad smb */
4935 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4937 (FILE_SYSTEM_POSIX_INFO
4938 *) (((char *) &pSMBr->hdr.Protocol) +
4941 le32_to_cpu(response_data->BlockSize);
4943 * much prefer larger but if server doesn't report
4944 * a valid size than 4K is a reasonable minimum
4946 if (FSData->f_bsize < 512)
4947 FSData->f_bsize = 4096;
4950 le64_to_cpu(response_data->TotalBlocks);
4952 le64_to_cpu(response_data->BlocksAvail);
4953 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4954 FSData->f_bavail = FSData->f_bfree;
4957 le64_to_cpu(response_data->UserBlocksAvail);
4959 if (response_data->TotalFileNodes != cpu_to_le64(-1))
4961 le64_to_cpu(response_data->TotalFileNodes);
4962 if (response_data->FreeFileNodes != cpu_to_le64(-1))
4964 le64_to_cpu(response_data->FreeFileNodes);
4967 cifs_buf_release(pSMB);
4977 * We can not use write of zero bytes trick to set file size due to need for
4978 * large file support. Also note that this SetPathInfo is preferred to
4979 * SetFileInfo based method in next routine which is only needed to work around
4980 * a sharing violation bugin Samba which this routine can run into.
4983 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
4984 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
4985 bool set_allocation)
4987 struct smb_com_transaction2_spi_req *pSMB = NULL;
4988 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4989 struct file_end_of_file_info *parm_data;
4992 int bytes_returned = 0;
4993 int remap = cifs_remap(cifs_sb);
4995 __u16 params, byte_count, data_count, param_offset, offset;
4997 cifs_dbg(FYI, "In SetEOF\n");
4999 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5004 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5006 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5007 PATH_MAX, cifs_sb->local_nls, remap);
5008 name_len++; /* trailing null */
5011 name_len = copy_path_name(pSMB->FileName, file_name);
5013 params = 6 + name_len;
5014 data_count = sizeof(struct file_end_of_file_info);
5015 pSMB->MaxParameterCount = cpu_to_le16(2);
5016 pSMB->MaxDataCount = cpu_to_le16(4100);
5017 pSMB->MaxSetupCount = 0;
5021 pSMB->Reserved2 = 0;
5022 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5023 InformationLevel) - 4;
5024 offset = param_offset + params;
5025 if (set_allocation) {
5026 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5027 pSMB->InformationLevel =
5028 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5030 pSMB->InformationLevel =
5031 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5032 } else /* Set File Size */ {
5033 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5034 pSMB->InformationLevel =
5035 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5037 pSMB->InformationLevel =
5038 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5042 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5044 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5045 pSMB->DataOffset = cpu_to_le16(offset);
5046 pSMB->SetupCount = 1;
5047 pSMB->Reserved3 = 0;
5048 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5049 byte_count = 3 /* pad */ + params + data_count;
5050 pSMB->DataCount = cpu_to_le16(data_count);
5051 pSMB->TotalDataCount = pSMB->DataCount;
5052 pSMB->ParameterCount = cpu_to_le16(params);
5053 pSMB->TotalParameterCount = pSMB->ParameterCount;
5054 pSMB->Reserved4 = 0;
5055 inc_rfc1001_len(pSMB, byte_count);
5056 parm_data->FileSize = cpu_to_le64(size);
5057 pSMB->ByteCount = cpu_to_le16(byte_count);
5058 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5059 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5061 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
5063 cifs_buf_release(pSMB);
5072 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5073 struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
5075 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5076 struct file_end_of_file_info *parm_data;
5078 __u16 params, param_offset, offset, byte_count, count;
5080 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5082 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5087 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5088 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
5091 pSMB->MaxSetupCount = 0;
5095 pSMB->Reserved2 = 0;
5096 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5097 offset = param_offset + params;
5099 count = sizeof(struct file_end_of_file_info);
5100 pSMB->MaxParameterCount = cpu_to_le16(2);
5101 /* BB find exact max SMB PDU from sess structure BB */
5102 pSMB->MaxDataCount = cpu_to_le16(1000);
5103 pSMB->SetupCount = 1;
5104 pSMB->Reserved3 = 0;
5105 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5106 byte_count = 3 /* pad */ + params + count;
5107 pSMB->DataCount = cpu_to_le16(count);
5108 pSMB->ParameterCount = cpu_to_le16(params);
5109 pSMB->TotalDataCount = pSMB->DataCount;
5110 pSMB->TotalParameterCount = pSMB->ParameterCount;
5111 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5112 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5114 (struct file_end_of_file_info *)(((char *)pSMB) + offset + 4);
5115 pSMB->DataOffset = cpu_to_le16(offset);
5116 parm_data->FileSize = cpu_to_le64(size);
5117 pSMB->Fid = cfile->fid.netfid;
5118 if (set_allocation) {
5119 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5120 pSMB->InformationLevel =
5121 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5123 pSMB->InformationLevel =
5124 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5125 } else /* Set File Size */ {
5126 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5127 pSMB->InformationLevel =
5128 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5130 pSMB->InformationLevel =
5131 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5133 pSMB->Reserved4 = 0;
5134 inc_rfc1001_len(pSMB, byte_count);
5135 pSMB->ByteCount = cpu_to_le16(byte_count);
5136 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5137 cifs_small_buf_release(pSMB);
5139 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5143 /* Note: On -EAGAIN error only caller can retry on handle based calls
5144 since file handle passed in no longer valid */
5149 /* Some legacy servers such as NT4 require that the file times be set on
5150 an open handle, rather than by pathname - this is awkward due to
5151 potential access conflicts on the open, but it is unavoidable for these
5152 old servers since the only other choice is to go from 100 nanosecond DCE
5153 time and resort to the original setpathinfo level which takes the ancient
5154 DOS time format with 2 second granularity */
5156 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5157 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5159 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5162 __u16 params, param_offset, offset, byte_count, count;
5164 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
5165 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5170 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5171 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5174 pSMB->MaxSetupCount = 0;
5178 pSMB->Reserved2 = 0;
5179 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5180 offset = param_offset + params;
5182 data_offset = (char *)pSMB +
5183 offsetof(struct smb_hdr, Protocol) + offset;
5185 count = sizeof(FILE_BASIC_INFO);
5186 pSMB->MaxParameterCount = cpu_to_le16(2);
5187 /* BB find max SMB PDU from sess */
5188 pSMB->MaxDataCount = cpu_to_le16(1000);
5189 pSMB->SetupCount = 1;
5190 pSMB->Reserved3 = 0;
5191 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5192 byte_count = 3 /* pad */ + params + count;
5193 pSMB->DataCount = cpu_to_le16(count);
5194 pSMB->ParameterCount = cpu_to_le16(params);
5195 pSMB->TotalDataCount = pSMB->DataCount;
5196 pSMB->TotalParameterCount = pSMB->ParameterCount;
5197 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5198 pSMB->DataOffset = cpu_to_le16(offset);
5200 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5201 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5203 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5204 pSMB->Reserved4 = 0;
5205 inc_rfc1001_len(pSMB, byte_count);
5206 pSMB->ByteCount = cpu_to_le16(byte_count);
5207 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5208 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5209 cifs_small_buf_release(pSMB);
5211 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5214 /* Note: On -EAGAIN error only caller can retry on handle based calls
5215 since file handle passed in no longer valid */
5221 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
5222 bool delete_file, __u16 fid, __u32 pid_of_opener)
5224 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5227 __u16 params, param_offset, offset, byte_count, count;
5229 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
5230 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5235 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5236 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5239 pSMB->MaxSetupCount = 0;
5243 pSMB->Reserved2 = 0;
5244 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5245 offset = param_offset + params;
5247 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5248 data_offset = (char *)(pSMB) + offset + 4;
5251 pSMB->MaxParameterCount = cpu_to_le16(2);
5252 /* BB find max SMB PDU from sess */
5253 pSMB->MaxDataCount = cpu_to_le16(1000);
5254 pSMB->SetupCount = 1;
5255 pSMB->Reserved3 = 0;
5256 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5257 byte_count = 3 /* pad */ + params + count;
5258 pSMB->DataCount = cpu_to_le16(count);
5259 pSMB->ParameterCount = cpu_to_le16(params);
5260 pSMB->TotalDataCount = pSMB->DataCount;
5261 pSMB->TotalParameterCount = pSMB->ParameterCount;
5262 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5263 pSMB->DataOffset = cpu_to_le16(offset);
5265 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5266 pSMB->Reserved4 = 0;
5267 inc_rfc1001_len(pSMB, byte_count);
5268 pSMB->ByteCount = cpu_to_le16(byte_count);
5269 *data_offset = delete_file ? 1 : 0;
5270 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5271 cifs_small_buf_release(pSMB);
5273 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
5279 CIFSSMBSetPathInfoFB(const unsigned int xid, struct cifs_tcon *tcon,
5280 const char *fileName, const FILE_BASIC_INFO *data,
5281 const struct nls_table *nls_codepage,
5282 struct cifs_sb_info *cifs_sb)
5285 struct cifs_open_parms oparms;
5286 struct cifs_fid fid;
5289 oparms = (struct cifs_open_parms) {
5292 .desired_access = GENERIC_WRITE,
5293 .create_options = cifs_create_options(cifs_sb, 0),
5294 .disposition = FILE_OPEN,
5299 rc = CIFS_open(xid, &oparms, &oplock, NULL);
5303 rc = CIFSSMBSetFileInfo(xid, tcon, data, fid.netfid, current->tgid);
5304 CIFSSMBClose(xid, tcon, fid.netfid);
5311 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5312 const char *fileName, const FILE_BASIC_INFO *data,
5313 const struct nls_table *nls_codepage,
5314 struct cifs_sb_info *cifs_sb)
5316 TRANSACTION2_SPI_REQ *pSMB = NULL;
5317 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5320 int bytes_returned = 0;
5322 __u16 params, param_offset, offset, byte_count, count;
5323 int remap = cifs_remap(cifs_sb);
5325 cifs_dbg(FYI, "In SetTimes\n");
5328 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5333 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5335 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5336 PATH_MAX, nls_codepage, remap);
5337 name_len++; /* trailing null */
5340 name_len = copy_path_name(pSMB->FileName, fileName);
5343 params = 6 + name_len;
5344 count = sizeof(FILE_BASIC_INFO);
5345 pSMB->MaxParameterCount = cpu_to_le16(2);
5346 /* BB find max SMB PDU from sess structure BB */
5347 pSMB->MaxDataCount = cpu_to_le16(1000);
5348 pSMB->MaxSetupCount = 0;
5352 pSMB->Reserved2 = 0;
5353 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5354 InformationLevel) - 4;
5355 offset = param_offset + params;
5356 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5357 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5358 pSMB->DataOffset = cpu_to_le16(offset);
5359 pSMB->SetupCount = 1;
5360 pSMB->Reserved3 = 0;
5361 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5362 byte_count = 3 /* pad */ + params + count;
5364 pSMB->DataCount = cpu_to_le16(count);
5365 pSMB->ParameterCount = cpu_to_le16(params);
5366 pSMB->TotalDataCount = pSMB->DataCount;
5367 pSMB->TotalParameterCount = pSMB->ParameterCount;
5368 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5369 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5371 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5372 pSMB->Reserved4 = 0;
5373 inc_rfc1001_len(pSMB, byte_count);
5374 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5375 pSMB->ByteCount = cpu_to_le16(byte_count);
5376 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5377 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5379 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
5381 cifs_buf_release(pSMB);
5386 if (rc == -EOPNOTSUPP)
5387 return CIFSSMBSetPathInfoFB(xid, tcon, fileName, data,
5388 nls_codepage, cifs_sb);
5394 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5395 const struct cifs_unix_set_info_args *args)
5397 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
5398 u64 mode = args->mode;
5400 if (uid_valid(args->uid))
5401 uid = from_kuid(&init_user_ns, args->uid);
5402 if (gid_valid(args->gid))
5403 gid = from_kgid(&init_user_ns, args->gid);
5406 * Samba server ignores set of file size to zero due to bugs in some
5407 * older clients, but we should be precise - we use SetFileSize to
5408 * set file size and do not want to truncate file size to zero
5409 * accidentally as happened on one Samba server beta by putting
5410 * zero instead of -1 here
5412 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5413 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5414 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5415 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5416 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5417 data_offset->Uid = cpu_to_le64(uid);
5418 data_offset->Gid = cpu_to_le64(gid);
5419 /* better to leave device as zero when it is */
5420 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5421 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5422 data_offset->Permissions = cpu_to_le64(mode);
5425 data_offset->Type = cpu_to_le32(UNIX_FILE);
5426 else if (S_ISDIR(mode))
5427 data_offset->Type = cpu_to_le32(UNIX_DIR);
5428 else if (S_ISLNK(mode))
5429 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5430 else if (S_ISCHR(mode))
5431 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5432 else if (S_ISBLK(mode))
5433 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5434 else if (S_ISFIFO(mode))
5435 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5436 else if (S_ISSOCK(mode))
5437 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5441 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5442 const struct cifs_unix_set_info_args *args,
5443 u16 fid, u32 pid_of_opener)
5445 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5448 u16 params, param_offset, offset, byte_count, count;
5450 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
5451 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5456 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5457 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5460 pSMB->MaxSetupCount = 0;
5464 pSMB->Reserved2 = 0;
5465 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5466 offset = param_offset + params;
5468 data_offset = (char *)pSMB +
5469 offsetof(struct smb_hdr, Protocol) + offset;
5471 count = sizeof(FILE_UNIX_BASIC_INFO);
5473 pSMB->MaxParameterCount = cpu_to_le16(2);
5474 /* BB find max SMB PDU from sess */
5475 pSMB->MaxDataCount = cpu_to_le16(1000);
5476 pSMB->SetupCount = 1;
5477 pSMB->Reserved3 = 0;
5478 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5479 byte_count = 3 /* pad */ + params + count;
5480 pSMB->DataCount = cpu_to_le16(count);
5481 pSMB->ParameterCount = cpu_to_le16(params);
5482 pSMB->TotalDataCount = pSMB->DataCount;
5483 pSMB->TotalParameterCount = pSMB->ParameterCount;
5484 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5485 pSMB->DataOffset = cpu_to_le16(offset);
5487 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5488 pSMB->Reserved4 = 0;
5489 inc_rfc1001_len(pSMB, byte_count);
5490 pSMB->ByteCount = cpu_to_le16(byte_count);
5492 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
5494 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5495 cifs_small_buf_release(pSMB);
5497 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5500 /* Note: On -EAGAIN error only caller can retry on handle based calls
5501 since file handle passed in no longer valid */
5507 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5508 const char *file_name,
5509 const struct cifs_unix_set_info_args *args,
5510 const struct nls_table *nls_codepage, int remap)
5512 TRANSACTION2_SPI_REQ *pSMB = NULL;
5513 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5516 int bytes_returned = 0;
5517 FILE_UNIX_BASIC_INFO *data_offset;
5518 __u16 params, param_offset, offset, count, byte_count;
5520 cifs_dbg(FYI, "In SetUID/GID/Mode\n");
5522 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5527 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5529 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5530 PATH_MAX, nls_codepage, remap);
5531 name_len++; /* trailing null */
5534 name_len = copy_path_name(pSMB->FileName, file_name);
5537 params = 6 + name_len;
5538 count = sizeof(FILE_UNIX_BASIC_INFO);
5539 pSMB->MaxParameterCount = cpu_to_le16(2);
5540 /* BB find max SMB PDU from sess structure BB */
5541 pSMB->MaxDataCount = cpu_to_le16(1000);
5542 pSMB->MaxSetupCount = 0;
5546 pSMB->Reserved2 = 0;
5547 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5548 InformationLevel) - 4;
5549 offset = param_offset + params;
5550 /* SMB offsets are from the beginning of SMB which is 4 bytes in, after RFC1001 field */
5551 data_offset = (FILE_UNIX_BASIC_INFO *)((char *) pSMB + offset + 4);
5552 memset(data_offset, 0, count);
5553 pSMB->DataOffset = cpu_to_le16(offset);
5554 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5555 pSMB->SetupCount = 1;
5556 pSMB->Reserved3 = 0;
5557 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5558 byte_count = 3 /* pad */ + params + count;
5559 pSMB->ParameterCount = cpu_to_le16(params);
5560 pSMB->DataCount = cpu_to_le16(count);
5561 pSMB->TotalParameterCount = pSMB->ParameterCount;
5562 pSMB->TotalDataCount = pSMB->DataCount;
5563 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5564 pSMB->Reserved4 = 0;
5565 inc_rfc1001_len(pSMB, byte_count);
5567 cifs_fill_unix_set_info(data_offset, args);
5569 pSMB->ByteCount = cpu_to_le16(byte_count);
5570 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5571 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5573 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
5575 cifs_buf_release(pSMB);
5581 #ifdef CONFIG_CIFS_XATTR
5583 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
5584 * function used by listxattr and getxattr type calls. When ea_name is set,
5585 * it looks for that attribute name and stuffs that value into the EAData
5586 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
5587 * buffer. In both cases, the return value is either the length of the
5588 * resulting data or a negative error code. If EAData is a NULL pointer then
5589 * the data isn't copied to it, but the length is returned.
5592 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
5593 const unsigned char *searchName, const unsigned char *ea_name,
5594 char *EAData, size_t buf_size,
5595 struct cifs_sb_info *cifs_sb)
5597 /* BB assumes one setup word */
5598 TRANSACTION2_QPI_REQ *pSMB = NULL;
5599 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5600 int remap = cifs_remap(cifs_sb);
5601 struct nls_table *nls_codepage = cifs_sb->local_nls;
5605 struct fealist *ea_response_data;
5606 struct fea *temp_fea;
5609 __u16 params, byte_count, data_offset;
5610 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
5612 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
5614 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5619 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5621 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
5622 PATH_MAX, nls_codepage, remap);
5623 list_len++; /* trailing null */
5626 list_len = copy_path_name(pSMB->FileName, searchName);
5629 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
5630 pSMB->TotalDataCount = 0;
5631 pSMB->MaxParameterCount = cpu_to_le16(2);
5632 /* BB find exact max SMB PDU from sess structure BB */
5633 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
5634 pSMB->MaxSetupCount = 0;
5638 pSMB->Reserved2 = 0;
5639 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5640 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5641 pSMB->DataCount = 0;
5642 pSMB->DataOffset = 0;
5643 pSMB->SetupCount = 1;
5644 pSMB->Reserved3 = 0;
5645 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5646 byte_count = params + 1 /* pad */ ;
5647 pSMB->TotalParameterCount = cpu_to_le16(params);
5648 pSMB->ParameterCount = pSMB->TotalParameterCount;
5649 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5650 pSMB->Reserved4 = 0;
5651 inc_rfc1001_len(pSMB, byte_count);
5652 pSMB->ByteCount = cpu_to_le16(byte_count);
5654 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5655 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5657 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
5662 /* BB also check enough total bytes returned */
5663 /* BB we need to improve the validity checking
5664 of these trans2 responses */
5666 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5667 if (rc || get_bcc(&pSMBr->hdr) < 4) {
5668 rc = -EIO; /* bad smb */
5672 /* check that length of list is not more than bcc */
5673 /* check that each entry does not go beyond length
5675 /* check that each element of each entry does not
5676 go beyond end of list */
5677 /* validate_trans2_offsets() */
5678 /* BB check if start of smb + data_offset > &bcc+ bcc */
5680 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5681 ea_response_data = (struct fealist *)
5682 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5684 list_len = le32_to_cpu(ea_response_data->list_len);
5685 cifs_dbg(FYI, "ea length %d\n", list_len);
5686 if (list_len <= 8) {
5687 cifs_dbg(FYI, "empty EA list returned from server\n");
5688 /* didn't find the named attribute */
5694 /* make sure list_len doesn't go past end of SMB */
5695 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
5696 if ((char *)ea_response_data + list_len > end_of_smb) {
5697 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
5702 /* account for ea list len */
5704 temp_fea = &ea_response_data->list;
5705 temp_ptr = (char *)temp_fea;
5706 while (list_len > 0) {
5707 unsigned int name_len;
5712 /* make sure we can read name_len and value_len */
5714 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
5719 name_len = temp_fea->name_len;
5720 value_len = le16_to_cpu(temp_fea->value_len);
5721 list_len -= name_len + 1 + value_len;
5723 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
5729 if (ea_name_len == name_len &&
5730 memcmp(ea_name, temp_ptr, name_len) == 0) {
5731 temp_ptr += name_len + 1;
5735 if ((size_t)value_len > buf_size) {
5739 memcpy(EAData, temp_ptr, value_len);
5743 /* account for prefix user. and trailing null */
5744 rc += (5 + 1 + name_len);
5745 if (rc < (int) buf_size) {
5746 memcpy(EAData, "user.", 5);
5748 memcpy(EAData, temp_ptr, name_len);
5750 /* null terminate name */
5753 } else if (buf_size == 0) {
5754 /* skip copy - calc size only */
5756 /* stop before overrun buffer */
5761 temp_ptr += name_len + 1 + value_len;
5762 temp_fea = (struct fea *)temp_ptr;
5765 /* didn't find the named attribute */
5770 cifs_buf_release(pSMB);
5778 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
5779 const char *fileName, const char *ea_name, const void *ea_value,
5780 const __u16 ea_value_len, const struct nls_table *nls_codepage,
5781 struct cifs_sb_info *cifs_sb)
5783 struct smb_com_transaction2_spi_req *pSMB = NULL;
5784 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5785 struct fealist *parm_data;
5788 int bytes_returned = 0;
5789 __u16 params, param_offset, byte_count, offset, count;
5790 int remap = cifs_remap(cifs_sb);
5792 cifs_dbg(FYI, "In SetEA\n");
5794 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5799 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5801 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5802 PATH_MAX, nls_codepage, remap);
5803 name_len++; /* trailing null */
5806 name_len = copy_path_name(pSMB->FileName, fileName);
5809 params = 6 + name_len;
5811 /* done calculating parms using name_len of file name,
5812 now use name_len to calculate length of ea name
5813 we are going to create in the inode xattrs */
5814 if (ea_name == NULL)
5817 name_len = strnlen(ea_name, 255);
5819 count = sizeof(*parm_data) + 1 + ea_value_len + name_len;
5820 pSMB->MaxParameterCount = cpu_to_le16(2);
5821 /* BB find max SMB PDU from sess */
5822 pSMB->MaxDataCount = cpu_to_le16(1000);
5823 pSMB->MaxSetupCount = 0;
5827 pSMB->Reserved2 = 0;
5828 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5829 InformationLevel) - 4;
5830 offset = param_offset + params;
5831 pSMB->InformationLevel =
5832 cpu_to_le16(SMB_SET_FILE_EA);
5834 parm_data = (void *)pSMB + offsetof(struct smb_hdr, Protocol) + offset;
5835 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5836 pSMB->DataOffset = cpu_to_le16(offset);
5837 pSMB->SetupCount = 1;
5838 pSMB->Reserved3 = 0;
5839 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5840 byte_count = 3 /* pad */ + params + count;
5841 pSMB->DataCount = cpu_to_le16(count);
5842 parm_data->list_len = cpu_to_le32(count);
5843 parm_data->list.EA_flags = 0;
5844 /* we checked above that name len is less than 255 */
5845 parm_data->list.name_len = (__u8)name_len;
5846 /* EA names are always ASCII */
5848 strncpy(parm_data->list.name, ea_name, name_len);
5849 parm_data->list.name[name_len] = '\0';
5850 parm_data->list.value_len = cpu_to_le16(ea_value_len);
5851 /* caller ensures that ea_value_len is less than 64K but
5852 we need to ensure that it fits within the smb */
5854 /*BB add length check to see if it would fit in
5855 negotiated SMB buffer size BB */
5856 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5858 memcpy(parm_data->list.name + name_len + 1,
5859 ea_value, ea_value_len);
5861 pSMB->TotalDataCount = pSMB->DataCount;
5862 pSMB->ParameterCount = cpu_to_le16(params);
5863 pSMB->TotalParameterCount = pSMB->ParameterCount;
5864 pSMB->Reserved4 = 0;
5865 inc_rfc1001_len(pSMB, byte_count);
5866 pSMB->ByteCount = cpu_to_le16(byte_count);
5867 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5868 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5870 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
5872 cifs_buf_release(pSMB);