4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Contains the routines for constructing the SMB PDUs themselves
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */
25 /* These are mostly routines that operate on a pathname, or on a tree id */
26 /* (mounted volume), but there are eight handle based routines which must be */
27 /* treated slightly differently for reconnection purposes since we never */
28 /* want to reuse a stale file handle and only the caller knows the file info */
31 #include <linux/kernel.h>
32 #include <linux/vfs.h>
33 #include <linux/slab.h>
34 #include <linux/posix_acl_xattr.h>
35 #include <linux/pagemap.h>
36 #include <linux/swap.h>
37 #include <linux/task_io_accounting_ops.h>
38 #include <asm/uaccess.h>
42 #include "cifsproto.h"
43 #include "cifs_unicode.h"
44 #include "cifs_debug.h"
47 #ifdef CONFIG_CIFS_POSIX
52 #ifdef CONFIG_CIFS_WEAK_PW_HASH
53 {LANMAN_PROT, "\2LM1.2X002"},
54 {LANMAN2_PROT, "\2LANMAN2.1"},
55 #endif /* weak password hashing for legacy clients */
56 {CIFS_PROT, "\2NT LM 0.12"},
57 {POSIX_PROT, "\2POSIX 2"},
65 #ifdef CONFIG_CIFS_WEAK_PW_HASH
66 {LANMAN_PROT, "\2LM1.2X002"},
67 {LANMAN2_PROT, "\2LANMAN2.1"},
68 #endif /* weak password hashing for legacy clients */
69 {CIFS_PROT, "\2NT LM 0.12"},
74 /* define the number of elements in the cifs dialect array */
75 #ifdef CONFIG_CIFS_POSIX
76 #ifdef CONFIG_CIFS_WEAK_PW_HASH
77 #define CIFS_NUM_PROT 4
79 #define CIFS_NUM_PROT 2
80 #endif /* CIFS_WEAK_PW_HASH */
82 #ifdef CONFIG_CIFS_WEAK_PW_HASH
83 #define CIFS_NUM_PROT 3
85 #define CIFS_NUM_PROT 1
86 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
87 #endif /* CIFS_POSIX */
90 * Mark as invalid, all open files on tree connections since they
91 * were closed when session to server was lost.
94 cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
96 struct cifsFileInfo *open_file = NULL;
97 struct list_head *tmp;
98 struct list_head *tmp1;
100 /* list all files open on tree connection and mark them invalid */
101 spin_lock(&cifs_file_list_lock);
102 list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
103 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
104 open_file->invalidHandle = true;
105 open_file->oplock_break_cancelled = true;
107 spin_unlock(&cifs_file_list_lock);
109 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
114 /* reconnect the socket, tcon, and smb session if needed */
116 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
119 struct cifs_ses *ses;
120 struct TCP_Server_Info *server;
121 struct nls_table *nls_codepage;
124 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
125 * tcp and smb session status done differently for those three - in the
132 server = ses->server;
135 * only tree disconnect, open, and write, (and ulogoff which does not
136 * have tcon) are allowed as we start force umount
138 if (tcon->tidStatus == CifsExiting) {
139 if (smb_command != SMB_COM_WRITE_ANDX &&
140 smb_command != SMB_COM_OPEN_ANDX &&
141 smb_command != SMB_COM_TREE_DISCONNECT) {
142 cifs_dbg(FYI, "can not send cmd %d while umounting\n",
149 * Give demultiplex thread up to 10 seconds to reconnect, should be
150 * greater than cifs socket timeout which is 7 seconds
152 while (server->tcpStatus == CifsNeedReconnect) {
153 wait_event_interruptible_timeout(server->response_q,
154 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
156 /* are we still trying to reconnect? */
157 if (server->tcpStatus != CifsNeedReconnect)
161 * on "soft" mounts we wait once. Hard mounts keep
162 * retrying until process is killed or server comes
166 cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
171 if (!ses->need_reconnect && !tcon->need_reconnect)
174 nls_codepage = load_nls_default();
177 * need to prevent multiple threads trying to simultaneously
178 * reconnect the same SMB session
180 mutex_lock(&ses->session_mutex);
181 rc = cifs_negotiate_protocol(0, ses);
182 if (rc == 0 && ses->need_reconnect)
183 rc = cifs_setup_session(0, ses, nls_codepage);
185 /* do we need to reconnect tcon? */
186 if (rc || !tcon->need_reconnect) {
187 mutex_unlock(&ses->session_mutex);
191 cifs_mark_open_files_invalid(tcon);
192 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
193 mutex_unlock(&ses->session_mutex);
194 cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc);
200 * FIXME: check if wsize needs updated due to negotiated smb buffer
203 atomic_inc(&tconInfoReconnectCount);
205 /* tell server Unix caps we support */
206 if (ses->capabilities & CAP_UNIX)
207 reset_cifs_unix_caps(0, tcon, NULL, NULL);
210 * Removed call to reopen open files here. It is safer (and faster) to
211 * reopen files one at a time as needed in read and write.
213 * FIXME: what about file locks? don't we need to reclaim them ASAP?
218 * Check if handle based operation so we know whether we can continue
219 * or not without returning to caller to reset file handle
221 switch (smb_command) {
222 case SMB_COM_READ_ANDX:
223 case SMB_COM_WRITE_ANDX:
225 case SMB_COM_FIND_CLOSE2:
226 case SMB_COM_LOCKING_ANDX:
230 unload_nls(nls_codepage);
234 /* Allocate and return pointer to an SMB request buffer, and set basic
235 SMB information in the SMB header. If the return code is zero, this
236 function must have filled in request_buf pointer */
238 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
243 rc = cifs_reconnect_tcon(tcon, smb_command);
247 *request_buf = cifs_small_buf_get();
248 if (*request_buf == NULL) {
249 /* BB should we add a retry in here if not a writepage? */
253 header_assemble((struct smb_hdr *) *request_buf, smb_command,
257 cifs_stats_inc(&tcon->num_smbs_sent);
263 small_smb_init_no_tc(const int smb_command, const int wct,
264 struct cifs_ses *ses, void **request_buf)
267 struct smb_hdr *buffer;
269 rc = small_smb_init(smb_command, wct, NULL, request_buf);
273 buffer = (struct smb_hdr *)*request_buf;
274 buffer->Mid = get_next_mid(ses->server);
275 if (ses->capabilities & CAP_UNICODE)
276 buffer->Flags2 |= SMBFLG2_UNICODE;
277 if (ses->capabilities & CAP_STATUS32)
278 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
280 /* uid, tid can stay at zero as set in header assemble */
282 /* BB add support for turning on the signing when
283 this function is used after 1st of session setup requests */
288 /* If the return code is zero, this function must fill in request_buf pointer */
290 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
291 void **request_buf, void **response_buf)
293 *request_buf = cifs_buf_get();
294 if (*request_buf == NULL) {
295 /* BB should we add a retry in here if not a writepage? */
298 /* Although the original thought was we needed the response buf for */
299 /* potential retries of smb operations it turns out we can determine */
300 /* from the mid flags when the request buffer can be resent without */
301 /* having to use a second distinct buffer for the response */
303 *response_buf = *request_buf;
305 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
309 cifs_stats_inc(&tcon->num_smbs_sent);
314 /* If the return code is zero, this function must fill in request_buf pointer */
316 smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
317 void **request_buf, void **response_buf)
321 rc = cifs_reconnect_tcon(tcon, smb_command);
325 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
329 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
330 void **request_buf, void **response_buf)
332 if (tcon->ses->need_reconnect || tcon->need_reconnect)
335 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
338 static int validate_t2(struct smb_t2_rsp *pSMB)
340 unsigned int total_size;
342 /* check for plausible wct */
343 if (pSMB->hdr.WordCount < 10)
346 /* check for parm and data offset going beyond end of smb */
347 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
348 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
351 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
352 if (total_size >= 512)
355 /* check that bcc is at least as big as parms + data, and that it is
356 * less than negotiated smb buffer
358 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
359 if (total_size > get_bcc(&pSMB->hdr) ||
360 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
365 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
366 sizeof(struct smb_t2_rsp) + 16);
371 decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
375 char *guid = pSMBr->u.extended_response.GUID;
376 struct TCP_Server_Info *server = ses->server;
378 count = get_bcc(&pSMBr->hdr);
379 if (count < SMB1_CLIENT_GUID_SIZE)
382 spin_lock(&cifs_tcp_ses_lock);
383 if (server->srv_count > 1) {
384 spin_unlock(&cifs_tcp_ses_lock);
385 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
386 cifs_dbg(FYI, "server UID changed\n");
387 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
390 spin_unlock(&cifs_tcp_ses_lock);
391 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
394 if (count == SMB1_CLIENT_GUID_SIZE) {
395 server->sec_ntlmssp = true;
397 count -= SMB1_CLIENT_GUID_SIZE;
398 rc = decode_negTokenInit(
399 pSMBr->u.extended_response.SecurityBlob, count, server);
408 cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
410 bool srv_sign_required = server->sec_mode & server->vals->signing_required;
411 bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
412 bool mnt_sign_enabled = global_secflags & CIFSSEC_MAY_SIGN;
415 * Is signing required by mnt options? If not then check
416 * global_secflags to see if it is there.
418 if (!mnt_sign_required)
419 mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
423 * If signing is required then it's automatically enabled too,
424 * otherwise, check to see if the secflags allow it.
426 mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
427 (global_secflags & CIFSSEC_MAY_SIGN);
429 /* If server requires signing, does client allow it? */
430 if (srv_sign_required) {
431 if (!mnt_sign_enabled) {
432 cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!");
438 /* If client requires signing, does server allow it? */
439 if (mnt_sign_required) {
440 if (!srv_sign_enabled) {
441 cifs_dbg(VFS, "Server does not support signing!");
450 #ifdef CONFIG_CIFS_WEAK_PW_HASH
452 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
455 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
457 if (server->dialect != LANMAN_PROT && server->dialect != LANMAN2_PROT)
460 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
461 server->maxReq = min_t(unsigned int,
462 le16_to_cpu(rsp->MaxMpxCount),
464 set_credits(server, server->maxReq);
465 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
466 server->max_vcs = le16_to_cpu(rsp->MaxNumberVcs);
467 /* even though we do not use raw we might as well set this
468 accurately, in case we ever find a need for it */
469 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
470 server->max_rw = 0xFF00;
471 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
473 server->max_rw = 0;/* do not need to use raw anyway */
474 server->capabilities = CAP_MPX_MODE;
476 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
478 /* OS/2 often does not set timezone therefore
479 * we must use server time to calc time zone.
480 * Could deviate slightly from the right zone.
481 * Smallest defined timezone difference is 15 minutes
482 * (i.e. Nepal). Rounding up/down is done to match
485 int val, seconds, remain, result;
486 struct timespec ts, utc;
488 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
489 rsp->SrvTime.Time, 0);
490 cifs_dbg(FYI, "SrvTime %d sec since 1970 (utc: %d) diff: %d\n",
491 (int)ts.tv_sec, (int)utc.tv_sec,
492 (int)(utc.tv_sec - ts.tv_sec));
493 val = (int)(utc.tv_sec - ts.tv_sec);
495 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
496 remain = seconds % MIN_TZ_ADJ;
497 if (remain >= (MIN_TZ_ADJ / 2))
498 result += MIN_TZ_ADJ;
501 server->timeAdj = result;
503 server->timeAdj = (int)tmp;
504 server->timeAdj *= 60; /* also in seconds */
506 cifs_dbg(FYI, "server->timeAdj: %d seconds\n", server->timeAdj);
509 /* BB get server time for time conversions and add
510 code to use it and timezone since this is not UTC */
512 if (rsp->EncryptionKeyLength ==
513 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
514 memcpy(server->cryptkey, rsp->EncryptionKey,
515 CIFS_CRYPTO_KEY_SIZE);
516 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
517 return -EIO; /* need cryptkey unless plain text */
520 cifs_dbg(FYI, "LANMAN negotiated\n");
525 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
527 cifs_dbg(VFS, "mount failed, cifs module not built with CIFS_WEAK_PW_HASH support\n");
533 should_set_ext_sec_flag(enum securityEnum sectype)
540 if (global_secflags &
541 (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP))
550 CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
553 NEGOTIATE_RSP *pSMBr;
557 struct TCP_Server_Info *server = ses->server;
561 WARN(1, "%s: server is NULL!\n", __func__);
565 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
566 (void **) &pSMB, (void **) &pSMBr);
570 pSMB->hdr.Mid = get_next_mid(server);
571 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
573 if (should_set_ext_sec_flag(ses->sectype)) {
574 cifs_dbg(FYI, "Requesting extended security.");
575 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
579 for (i = 0; i < CIFS_NUM_PROT; i++) {
580 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
581 count += strlen(protocols[i].name) + 1;
582 /* null at end of source and target buffers anyway */
584 inc_rfc1001_len(pSMB, count);
585 pSMB->ByteCount = cpu_to_le16(count);
587 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
588 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
592 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
593 cifs_dbg(FYI, "Dialect: %d\n", server->dialect);
594 /* Check wct = 1 error case */
595 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
596 /* core returns wct = 1, but we do not ask for core - otherwise
597 small wct just comes when dialect index is -1 indicating we
598 could not negotiate a common dialect */
601 } else if (pSMBr->hdr.WordCount == 13) {
602 server->negflavor = CIFS_NEGFLAVOR_LANMAN;
603 rc = decode_lanman_negprot_rsp(server, pSMBr);
605 } else if (pSMBr->hdr.WordCount != 17) {
610 /* else wct == 17, NTLM or better */
612 server->sec_mode = pSMBr->SecurityMode;
613 if ((server->sec_mode & SECMODE_USER) == 0)
614 cifs_dbg(FYI, "share mode security\n");
616 /* one byte, so no need to convert this or EncryptionKeyLen from
618 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
620 set_credits(server, server->maxReq);
621 /* probably no need to store and check maxvcs */
622 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
623 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
624 cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
625 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
626 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
627 server->timeAdj *= 60;
629 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
630 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
631 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
632 CIFS_CRYPTO_KEY_SIZE);
633 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
634 server->capabilities & CAP_EXTENDED_SECURITY) &&
635 (pSMBr->EncryptionKeyLength == 0)) {
636 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
637 rc = decode_ext_sec_blob(ses, pSMBr);
638 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
639 rc = -EIO; /* no crypt key only if plain text pwd */
641 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
642 server->capabilities &= ~CAP_EXTENDED_SECURITY;
647 rc = cifs_enable_signing(server, ses->sign);
649 cifs_buf_release(pSMB);
651 cifs_dbg(FYI, "negprot rc %d\n", rc);
656 CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
658 struct smb_hdr *smb_buffer;
661 cifs_dbg(FYI, "In tree disconnect\n");
663 /* BB: do we need to check this? These should never be NULL. */
664 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
668 * No need to return error on this operation if tid invalidated and
669 * closed on server already e.g. due to tcp session crashing. Also,
670 * the tcon is no longer on the list, so no need to take lock before
673 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
676 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
677 (void **)&smb_buffer);
681 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
683 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc);
685 /* No need to return error on this operation if tid invalidated and
686 closed on server already e.g. due to tcp session crashing */
694 * This is a no-op for now. We're not really interested in the reply, but
695 * rather in the fact that the server sent one and that server->lstrp
698 * FIXME: maybe we should consider checking that the reply matches request?
701 cifs_echo_callback(struct mid_q_entry *mid)
703 struct TCP_Server_Info *server = mid->callback_data;
705 DeleteMidQEntry(mid);
706 add_credits(server, 1, CIFS_ECHO_OP);
710 CIFSSMBEcho(struct TCP_Server_Info *server)
715 struct smb_rqst rqst = { .rq_iov = &iov,
718 cifs_dbg(FYI, "In echo request\n");
720 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
724 /* set up echo request */
725 smb->hdr.Tid = 0xffff;
726 smb->hdr.WordCount = 1;
727 put_unaligned_le16(1, &smb->EchoCount);
728 put_bcc(1, &smb->hdr);
730 inc_rfc1001_len(smb, 3);
732 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
734 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback,
735 server, CIFS_ASYNC_OP | CIFS_ECHO_OP);
737 cifs_dbg(FYI, "Echo request failed: %d\n", rc);
739 cifs_small_buf_release(smb);
745 CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
747 LOGOFF_ANDX_REQ *pSMB;
750 cifs_dbg(FYI, "In SMBLogoff for session disconnect\n");
753 * BB: do we need to check validity of ses and server? They should
754 * always be valid since we have an active reference. If not, that
755 * should probably be a BUG()
757 if (!ses || !ses->server)
760 mutex_lock(&ses->session_mutex);
761 if (ses->need_reconnect)
762 goto session_already_dead; /* no need to send SMBlogoff if uid
763 already closed due to reconnect */
764 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
766 mutex_unlock(&ses->session_mutex);
770 pSMB->hdr.Mid = get_next_mid(ses->server);
772 if (ses->server->sign)
773 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
775 pSMB->hdr.Uid = ses->Suid;
777 pSMB->AndXCommand = 0xFF;
778 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
779 session_already_dead:
780 mutex_unlock(&ses->session_mutex);
782 /* if session dead then we do not need to do ulogoff,
783 since server closed smb session, no sense reporting
791 CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
792 const char *fileName, __u16 type,
793 const struct nls_table *nls_codepage, int remap)
795 TRANSACTION2_SPI_REQ *pSMB = NULL;
796 TRANSACTION2_SPI_RSP *pSMBr = NULL;
797 struct unlink_psx_rq *pRqD;
800 int bytes_returned = 0;
801 __u16 params, param_offset, offset, byte_count;
803 cifs_dbg(FYI, "In POSIX delete\n");
805 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
810 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
812 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
813 PATH_MAX, nls_codepage, remap);
814 name_len++; /* trailing null */
816 } else { /* BB add path length overrun check */
817 name_len = strnlen(fileName, PATH_MAX);
818 name_len++; /* trailing null */
819 strncpy(pSMB->FileName, fileName, name_len);
822 params = 6 + name_len;
823 pSMB->MaxParameterCount = cpu_to_le16(2);
824 pSMB->MaxDataCount = 0; /* BB double check this with jra */
825 pSMB->MaxSetupCount = 0;
830 param_offset = offsetof(struct smb_com_transaction2_spi_req,
831 InformationLevel) - 4;
832 offset = param_offset + params;
834 /* Setup pointer to Request Data (inode type) */
835 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
836 pRqD->type = cpu_to_le16(type);
837 pSMB->ParameterOffset = cpu_to_le16(param_offset);
838 pSMB->DataOffset = cpu_to_le16(offset);
839 pSMB->SetupCount = 1;
841 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
842 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
844 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
845 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
846 pSMB->ParameterCount = cpu_to_le16(params);
847 pSMB->TotalParameterCount = pSMB->ParameterCount;
848 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
850 inc_rfc1001_len(pSMB, byte_count);
851 pSMB->ByteCount = cpu_to_le16(byte_count);
852 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
853 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
855 cifs_dbg(FYI, "Posix delete returned %d\n", rc);
856 cifs_buf_release(pSMB);
858 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
867 CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
868 struct cifs_sb_info *cifs_sb)
870 DELETE_FILE_REQ *pSMB = NULL;
871 DELETE_FILE_RSP *pSMBr = NULL;
875 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
878 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
883 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
884 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
885 PATH_MAX, cifs_sb->local_nls,
887 name_len++; /* trailing null */
889 } else { /* BB improve check for buffer overruns BB */
890 name_len = strnlen(name, PATH_MAX);
891 name_len++; /* trailing null */
892 strncpy(pSMB->fileName, name, name_len);
894 pSMB->SearchAttributes =
895 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
896 pSMB->BufferFormat = 0x04;
897 inc_rfc1001_len(pSMB, name_len + 1);
898 pSMB->ByteCount = cpu_to_le16(name_len + 1);
899 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
900 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
901 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
903 cifs_dbg(FYI, "Error in RMFile = %d\n", rc);
905 cifs_buf_release(pSMB);
913 CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
914 struct cifs_sb_info *cifs_sb)
916 DELETE_DIRECTORY_REQ *pSMB = NULL;
917 DELETE_DIRECTORY_RSP *pSMBr = NULL;
921 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
923 cifs_dbg(FYI, "In CIFSSMBRmDir\n");
925 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
930 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
931 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
932 PATH_MAX, cifs_sb->local_nls,
934 name_len++; /* trailing null */
936 } else { /* BB improve check for buffer overruns BB */
937 name_len = strnlen(name, PATH_MAX);
938 name_len++; /* trailing null */
939 strncpy(pSMB->DirName, name, name_len);
942 pSMB->BufferFormat = 0x04;
943 inc_rfc1001_len(pSMB, name_len + 1);
944 pSMB->ByteCount = cpu_to_le16(name_len + 1);
945 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
946 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
947 cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
949 cifs_dbg(FYI, "Error in RMDir = %d\n", rc);
951 cifs_buf_release(pSMB);
958 CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
959 struct cifs_sb_info *cifs_sb)
962 CREATE_DIRECTORY_REQ *pSMB = NULL;
963 CREATE_DIRECTORY_RSP *pSMBr = NULL;
966 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
968 cifs_dbg(FYI, "In CIFSSMBMkDir\n");
970 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
975 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
976 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
977 PATH_MAX, cifs_sb->local_nls,
979 name_len++; /* trailing null */
981 } else { /* BB improve check for buffer overruns BB */
982 name_len = strnlen(name, PATH_MAX);
983 name_len++; /* trailing null */
984 strncpy(pSMB->DirName, name, name_len);
987 pSMB->BufferFormat = 0x04;
988 inc_rfc1001_len(pSMB, name_len + 1);
989 pSMB->ByteCount = cpu_to_le16(name_len + 1);
990 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
991 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
992 cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
994 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc);
996 cifs_buf_release(pSMB);
1003 CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
1004 __u32 posix_flags, __u64 mode, __u16 *netfid,
1005 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
1006 const char *name, const struct nls_table *nls_codepage,
1009 TRANSACTION2_SPI_REQ *pSMB = NULL;
1010 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1013 int bytes_returned = 0;
1014 __u16 params, param_offset, offset, byte_count, count;
1015 OPEN_PSX_REQ *pdata;
1016 OPEN_PSX_RSP *psx_rsp;
1018 cifs_dbg(FYI, "In POSIX Create\n");
1020 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1025 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1027 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1028 PATH_MAX, nls_codepage, remap);
1029 name_len++; /* trailing null */
1031 } else { /* BB improve the check for buffer overruns BB */
1032 name_len = strnlen(name, PATH_MAX);
1033 name_len++; /* trailing null */
1034 strncpy(pSMB->FileName, name, name_len);
1037 params = 6 + name_len;
1038 count = sizeof(OPEN_PSX_REQ);
1039 pSMB->MaxParameterCount = cpu_to_le16(2);
1040 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1041 pSMB->MaxSetupCount = 0;
1045 pSMB->Reserved2 = 0;
1046 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1047 InformationLevel) - 4;
1048 offset = param_offset + params;
1049 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1050 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1051 pdata->Permissions = cpu_to_le64(mode);
1052 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1053 pdata->OpenFlags = cpu_to_le32(*pOplock);
1054 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1055 pSMB->DataOffset = cpu_to_le16(offset);
1056 pSMB->SetupCount = 1;
1057 pSMB->Reserved3 = 0;
1058 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1059 byte_count = 3 /* pad */ + params + count;
1061 pSMB->DataCount = cpu_to_le16(count);
1062 pSMB->ParameterCount = cpu_to_le16(params);
1063 pSMB->TotalDataCount = pSMB->DataCount;
1064 pSMB->TotalParameterCount = pSMB->ParameterCount;
1065 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1066 pSMB->Reserved4 = 0;
1067 inc_rfc1001_len(pSMB, byte_count);
1068 pSMB->ByteCount = cpu_to_le16(byte_count);
1069 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1070 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1072 cifs_dbg(FYI, "Posix create returned %d\n", rc);
1073 goto psx_create_err;
1076 cifs_dbg(FYI, "copying inode info\n");
1077 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1079 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
1080 rc = -EIO; /* bad smb */
1081 goto psx_create_err;
1084 /* copy return information to pRetData */
1085 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1086 + le16_to_cpu(pSMBr->t2.DataOffset));
1088 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1090 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1091 /* Let caller know file was created so we can set the mode. */
1092 /* Do we care about the CreateAction in any other cases? */
1093 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1094 *pOplock |= CIFS_CREATE_ACTION;
1095 /* check to make sure response data is there */
1096 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1097 pRetData->Type = cpu_to_le32(-1); /* unknown */
1098 cifs_dbg(NOISY, "unknown type\n");
1100 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
1101 + sizeof(FILE_UNIX_BASIC_INFO)) {
1102 cifs_dbg(VFS, "Open response data too small\n");
1103 pRetData->Type = cpu_to_le32(-1);
1104 goto psx_create_err;
1106 memcpy((char *) pRetData,
1107 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1108 sizeof(FILE_UNIX_BASIC_INFO));
1112 cifs_buf_release(pSMB);
1114 if (posix_flags & SMB_O_DIRECTORY)
1115 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
1117 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
1125 static __u16 convert_disposition(int disposition)
1129 switch (disposition) {
1130 case FILE_SUPERSEDE:
1131 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1134 ofun = SMBOPEN_OAPPEND;
1137 ofun = SMBOPEN_OCREATE;
1140 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1142 case FILE_OVERWRITE:
1143 ofun = SMBOPEN_OTRUNC;
1145 case FILE_OVERWRITE_IF:
1146 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1149 cifs_dbg(FYI, "unknown disposition %d\n", disposition);
1150 ofun = SMBOPEN_OAPPEND; /* regular open */
1156 access_flags_to_smbopen_mode(const int access_flags)
1158 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1160 if (masked_flags == GENERIC_READ)
1161 return SMBOPEN_READ;
1162 else if (masked_flags == GENERIC_WRITE)
1163 return SMBOPEN_WRITE;
1165 /* just go for read/write */
1166 return SMBOPEN_READWRITE;
1170 SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
1171 const char *fileName, const int openDisposition,
1172 const int access_flags, const int create_options, __u16 *netfid,
1173 int *pOplock, FILE_ALL_INFO *pfile_info,
1174 const struct nls_table *nls_codepage, int remap)
1177 OPENX_REQ *pSMB = NULL;
1178 OPENX_RSP *pSMBr = NULL;
1184 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1189 pSMB->AndXCommand = 0xFF; /* none */
1191 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1192 count = 1; /* account for one byte pad to word boundary */
1194 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1195 fileName, PATH_MAX, nls_codepage, remap);
1196 name_len++; /* trailing null */
1198 } else { /* BB improve check for buffer overruns BB */
1199 count = 0; /* no pad */
1200 name_len = strnlen(fileName, PATH_MAX);
1201 name_len++; /* trailing null */
1202 strncpy(pSMB->fileName, fileName, name_len);
1204 if (*pOplock & REQ_OPLOCK)
1205 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1206 else if (*pOplock & REQ_BATCHOPLOCK)
1207 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1209 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1210 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1211 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1212 /* set file as system file if special file such
1213 as fifo and server expecting SFU style and
1214 no Unix extensions */
1216 if (create_options & CREATE_OPTION_SPECIAL)
1217 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1218 else /* BB FIXME BB */
1219 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1221 if (create_options & CREATE_OPTION_READONLY)
1222 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1225 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1226 CREATE_OPTIONS_MASK); */
1227 /* BB FIXME END BB */
1229 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1230 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1232 inc_rfc1001_len(pSMB, count);
1234 pSMB->ByteCount = cpu_to_le16(count);
1235 /* long_op set to 1 to allow for oplock break timeouts */
1236 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1237 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1238 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1240 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1242 /* BB verify if wct == 15 */
1244 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1246 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1247 /* Let caller know file was created so we can set the mode. */
1248 /* Do we care about the CreateAction in any other cases? */
1250 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1251 *pOplock |= CIFS_CREATE_ACTION; */
1255 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1256 pfile_info->LastAccessTime = 0; /* BB fixme */
1257 pfile_info->LastWriteTime = 0; /* BB fixme */
1258 pfile_info->ChangeTime = 0; /* BB fixme */
1259 pfile_info->Attributes =
1260 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1261 /* the file_info buf is endian converted by caller */
1262 pfile_info->AllocationSize =
1263 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1264 pfile_info->EndOfFile = pfile_info->AllocationSize;
1265 pfile_info->NumberOfLinks = cpu_to_le32(1);
1266 pfile_info->DeletePending = 0;
1270 cifs_buf_release(pSMB);
1277 CIFSSMBOpen(const unsigned int xid, struct cifs_tcon *tcon,
1278 const char *fileName, const int openDisposition,
1279 const int access_flags, const int create_options, __u16 *netfid,
1280 int *pOplock, FILE_ALL_INFO *pfile_info,
1281 const struct nls_table *nls_codepage, int remap)
1284 OPEN_REQ *pSMB = NULL;
1285 OPEN_RSP *pSMBr = NULL;
1291 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1296 pSMB->AndXCommand = 0xFF; /* none */
1298 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1299 count = 1; /* account for one byte pad to word boundary */
1301 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1302 fileName, PATH_MAX, nls_codepage, remap);
1303 name_len++; /* trailing null */
1305 pSMB->NameLength = cpu_to_le16(name_len);
1306 } else { /* BB improve check for buffer overruns BB */
1307 count = 0; /* no pad */
1308 name_len = strnlen(fileName, PATH_MAX);
1309 name_len++; /* trailing null */
1310 pSMB->NameLength = cpu_to_le16(name_len);
1311 strncpy(pSMB->fileName, fileName, name_len);
1313 if (*pOplock & REQ_OPLOCK)
1314 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1315 else if (*pOplock & REQ_BATCHOPLOCK)
1316 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1317 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1318 pSMB->AllocationSize = 0;
1319 /* set file as system file if special file such
1320 as fifo and server expecting SFU style and
1321 no Unix extensions */
1322 if (create_options & CREATE_OPTION_SPECIAL)
1323 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1325 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1327 /* XP does not handle ATTR_POSIX_SEMANTICS */
1328 /* but it helps speed up case sensitive checks for other
1329 servers such as Samba */
1330 if (tcon->ses->capabilities & CAP_UNIX)
1331 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1333 if (create_options & CREATE_OPTION_READONLY)
1334 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1336 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1337 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1338 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1339 /* BB Expirement with various impersonation levels and verify */
1340 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1341 pSMB->SecurityFlags =
1342 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1345 inc_rfc1001_len(pSMB, count);
1347 pSMB->ByteCount = cpu_to_le16(count);
1348 /* long_op set to 1 to allow for oplock break timeouts */
1349 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1350 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1351 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1353 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1355 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1356 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1357 /* Let caller know file was created so we can set the mode. */
1358 /* Do we care about the CreateAction in any other cases? */
1359 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1360 *pOplock |= CIFS_CREATE_ACTION;
1362 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1363 36 /* CreationTime to Attributes */);
1364 /* the file_info buf is endian converted by caller */
1365 pfile_info->AllocationSize = pSMBr->AllocationSize;
1366 pfile_info->EndOfFile = pSMBr->EndOfFile;
1367 pfile_info->NumberOfLinks = cpu_to_le32(1);
1368 pfile_info->DeletePending = 0;
1372 cifs_buf_release(pSMB);
1379 * Discard any remaining data in the current SMB. To do this, we borrow the
1383 cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1385 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
1386 int remaining = rfclen + 4 - server->total_read;
1387 struct cifs_readdata *rdata = mid->callback_data;
1389 while (remaining > 0) {
1392 length = cifs_read_from_socket(server, server->bigbuf,
1393 min_t(unsigned int, remaining,
1394 CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
1397 server->total_read += length;
1398 remaining -= length;
1401 dequeue_mid(mid, rdata->result);
1406 cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1409 unsigned int data_offset, data_len;
1410 struct cifs_readdata *rdata = mid->callback_data;
1411 char *buf = server->smallbuf;
1412 unsigned int buflen = get_rfc1002_length(buf) + 4;
1414 cifs_dbg(FYI, "%s: mid=%llu offset=%llu bytes=%u\n",
1415 __func__, mid->mid, rdata->offset, rdata->bytes);
1418 * read the rest of READ_RSP header (sans Data array), or whatever we
1419 * can if there's not enough data. At this point, we've read down to
1422 len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
1423 HEADER_SIZE(server) + 1;
1425 rdata->iov.iov_base = buf + HEADER_SIZE(server) - 1;
1426 rdata->iov.iov_len = len;
1428 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
1431 server->total_read += length;
1433 /* Was the SMB read successful? */
1434 rdata->result = server->ops->map_error(buf, false);
1435 if (rdata->result != 0) {
1436 cifs_dbg(FYI, "%s: server returned error %d\n",
1437 __func__, rdata->result);
1438 return cifs_readv_discard(server, mid);
1441 /* Is there enough to get to the rest of the READ_RSP header? */
1442 if (server->total_read < server->vals->read_rsp_size) {
1443 cifs_dbg(FYI, "%s: server returned short header. got=%u expected=%zu\n",
1444 __func__, server->total_read,
1445 server->vals->read_rsp_size);
1446 rdata->result = -EIO;
1447 return cifs_readv_discard(server, mid);
1450 data_offset = server->ops->read_data_offset(buf) + 4;
1451 if (data_offset < server->total_read) {
1453 * win2k8 sometimes sends an offset of 0 when the read
1454 * is beyond the EOF. Treat it as if the data starts just after
1457 cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n",
1458 __func__, data_offset);
1459 data_offset = server->total_read;
1460 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1461 /* data_offset is beyond the end of smallbuf */
1462 cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n",
1463 __func__, data_offset);
1464 rdata->result = -EIO;
1465 return cifs_readv_discard(server, mid);
1468 cifs_dbg(FYI, "%s: total_read=%u data_offset=%u\n",
1469 __func__, server->total_read, data_offset);
1471 len = data_offset - server->total_read;
1473 /* read any junk before data into the rest of smallbuf */
1474 rdata->iov.iov_base = buf + server->total_read;
1475 rdata->iov.iov_len = len;
1476 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
1479 server->total_read += length;
1482 /* set up first iov for signature check */
1483 rdata->iov.iov_base = buf;
1484 rdata->iov.iov_len = server->total_read;
1485 cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n",
1486 rdata->iov.iov_base, rdata->iov.iov_len);
1488 /* how much data is in the response? */
1489 data_len = server->ops->read_data_length(buf);
1490 if (data_offset + data_len > buflen) {
1491 /* data_len is corrupt -- discard frame */
1492 rdata->result = -EIO;
1493 return cifs_readv_discard(server, mid);
1496 length = rdata->read_into_pages(server, rdata, data_len);
1500 server->total_read += length;
1501 rdata->bytes = length;
1503 cifs_dbg(FYI, "total_read=%u buflen=%u remaining=%u\n",
1504 server->total_read, buflen, data_len);
1506 /* discard anything left over */
1507 if (server->total_read < buflen)
1508 return cifs_readv_discard(server, mid);
1510 dequeue_mid(mid, false);
1515 cifs_readv_callback(struct mid_q_entry *mid)
1517 struct cifs_readdata *rdata = mid->callback_data;
1518 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1519 struct TCP_Server_Info *server = tcon->ses->server;
1520 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
1522 .rq_pages = rdata->pages,
1523 .rq_npages = rdata->nr_pages,
1524 .rq_pagesz = rdata->pagesz,
1525 .rq_tailsz = rdata->tailsz };
1527 cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1528 __func__, mid->mid, mid->mid_state, rdata->result,
1531 switch (mid->mid_state) {
1532 case MID_RESPONSE_RECEIVED:
1533 /* result already set, check signature */
1537 rc = cifs_verify_signature(&rqst, server,
1538 mid->sequence_number);
1540 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
1543 /* FIXME: should this be counted toward the initiating task? */
1544 task_io_account_read(rdata->bytes);
1545 cifs_stats_bytes_read(tcon, rdata->bytes);
1547 case MID_REQUEST_SUBMITTED:
1548 case MID_RETRY_NEEDED:
1549 rdata->result = -EAGAIN;
1552 rdata->result = -EIO;
1555 queue_work(cifsiod_wq, &rdata->work);
1556 DeleteMidQEntry(mid);
1557 add_credits(server, 1, 0);
1560 /* cifs_async_readv - send an async write, and set up mid to handle result */
1562 cifs_async_readv(struct cifs_readdata *rdata)
1565 READ_REQ *smb = NULL;
1567 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1568 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
1571 cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
1572 __func__, rdata->offset, rdata->bytes);
1574 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1577 wct = 10; /* old style read */
1578 if ((rdata->offset >> 32) > 0) {
1579 /* can not handle this big offset for old */
1584 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1588 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1589 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1591 smb->AndXCommand = 0xFF; /* none */
1592 smb->Fid = rdata->cfile->fid.netfid;
1593 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1595 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1597 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1598 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1602 /* old style read */
1603 struct smb_com_readx_req *smbr =
1604 (struct smb_com_readx_req *)smb;
1605 smbr->ByteCount = 0;
1608 /* 4 for RFC1001 length + 1 for BCC */
1609 rdata->iov.iov_base = smb;
1610 rdata->iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1612 kref_get(&rdata->refcount);
1613 rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
1614 cifs_readv_callback, rdata, 0);
1617 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1619 kref_put(&rdata->refcount, cifs_readdata_release);
1621 cifs_small_buf_release(smb);
1626 CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
1627 unsigned int *nbytes, char **buf, int *pbuf_type)
1630 READ_REQ *pSMB = NULL;
1631 READ_RSP *pSMBr = NULL;
1632 char *pReadData = NULL;
1634 int resp_buf_type = 0;
1636 __u32 pid = io_parms->pid;
1637 __u16 netfid = io_parms->netfid;
1638 __u64 offset = io_parms->offset;
1639 struct cifs_tcon *tcon = io_parms->tcon;
1640 unsigned int count = io_parms->length;
1642 cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid);
1643 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1646 wct = 10; /* old style read */
1647 if ((offset >> 32) > 0) {
1648 /* can not handle this big offset for old */
1654 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1658 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1659 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1661 /* tcon and ses pointer are checked in smb_init */
1662 if (tcon->ses->server == NULL)
1663 return -ECONNABORTED;
1665 pSMB->AndXCommand = 0xFF; /* none */
1667 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1669 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1671 pSMB->Remaining = 0;
1672 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1673 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1675 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1677 /* old style read */
1678 struct smb_com_readx_req *pSMBW =
1679 (struct smb_com_readx_req *)pSMB;
1680 pSMBW->ByteCount = 0;
1683 iov[0].iov_base = (char *)pSMB;
1684 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1685 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1686 &resp_buf_type, CIFS_LOG_ERROR);
1687 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1688 pSMBr = (READ_RSP *)iov[0].iov_base;
1690 cifs_dbg(VFS, "Send error in read = %d\n", rc);
1692 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1693 data_length = data_length << 16;
1694 data_length += le16_to_cpu(pSMBr->DataLength);
1695 *nbytes = data_length;
1697 /*check that DataLength would not go beyond end of SMB */
1698 if ((data_length > CIFSMaxBufSize)
1699 || (data_length > count)) {
1700 cifs_dbg(FYI, "bad length %d for count %d\n",
1701 data_length, count);
1705 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1706 le16_to_cpu(pSMBr->DataOffset);
1707 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1708 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
1710 }*/ /* can not use copy_to_user when using page cache*/
1712 memcpy(*buf, pReadData, data_length);
1716 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1718 if (resp_buf_type == CIFS_SMALL_BUFFER)
1719 cifs_small_buf_release(iov[0].iov_base);
1720 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1721 cifs_buf_release(iov[0].iov_base);
1722 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1723 /* return buffer to caller to free */
1724 *buf = iov[0].iov_base;
1725 if (resp_buf_type == CIFS_SMALL_BUFFER)
1726 *pbuf_type = CIFS_SMALL_BUFFER;
1727 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1728 *pbuf_type = CIFS_LARGE_BUFFER;
1729 } /* else no valid buffer on return - leave as null */
1731 /* Note: On -EAGAIN error only caller can retry on handle based calls
1732 since file handle passed in no longer valid */
1738 CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
1739 unsigned int *nbytes, const char *buf,
1740 const char __user *ubuf, const int long_op)
1743 WRITE_REQ *pSMB = NULL;
1744 WRITE_RSP *pSMBr = NULL;
1745 int bytes_returned, wct;
1748 __u32 pid = io_parms->pid;
1749 __u16 netfid = io_parms->netfid;
1750 __u64 offset = io_parms->offset;
1751 struct cifs_tcon *tcon = io_parms->tcon;
1752 unsigned int count = io_parms->length;
1756 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
1757 if (tcon->ses == NULL)
1758 return -ECONNABORTED;
1760 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1764 if ((offset >> 32) > 0) {
1765 /* can not handle big offset for old srv */
1770 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1775 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1776 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1778 /* tcon and ses pointer are checked in smb_init */
1779 if (tcon->ses->server == NULL)
1780 return -ECONNABORTED;
1782 pSMB->AndXCommand = 0xFF; /* none */
1784 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1786 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1788 pSMB->Reserved = 0xFFFFFFFF;
1789 pSMB->WriteMode = 0;
1790 pSMB->Remaining = 0;
1792 /* Can increase buffer size if buffer is big enough in some cases ie we
1793 can send more if LARGE_WRITE_X capability returned by the server and if
1794 our buffer is big enough or if we convert to iovecs on socket writes
1795 and eliminate the copy to the CIFS buffer */
1796 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1797 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1799 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1803 if (bytes_sent > count)
1806 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1808 memcpy(pSMB->Data, buf, bytes_sent);
1810 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1811 cifs_buf_release(pSMB);
1814 } else if (count != 0) {
1816 cifs_buf_release(pSMB);
1818 } /* else setting file size with write of zero bytes */
1820 byte_count = bytes_sent + 1; /* pad */
1821 else /* wct == 12 */
1822 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1824 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1825 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1826 inc_rfc1001_len(pSMB, byte_count);
1829 pSMB->ByteCount = cpu_to_le16(byte_count);
1830 else { /* old style write has byte count 4 bytes earlier
1832 struct smb_com_writex_req *pSMBW =
1833 (struct smb_com_writex_req *)pSMB;
1834 pSMBW->ByteCount = cpu_to_le16(byte_count);
1837 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1838 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1839 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1841 cifs_dbg(FYI, "Send error in write = %d\n", rc);
1843 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1844 *nbytes = (*nbytes) << 16;
1845 *nbytes += le16_to_cpu(pSMBr->Count);
1848 * Mask off high 16 bits when bytes written as returned by the
1849 * server is greater than bytes requested by the client. Some
1850 * OS/2 servers are known to set incorrect CountHigh values.
1852 if (*nbytes > count)
1856 cifs_buf_release(pSMB);
1858 /* Note: On -EAGAIN error only caller can retry on handle based calls
1859 since file handle passed in no longer valid */
1865 cifs_writedata_release(struct kref *refcount)
1867 struct cifs_writedata *wdata = container_of(refcount,
1868 struct cifs_writedata, refcount);
1871 cifsFileInfo_put(wdata->cfile);
1877 * Write failed with a retryable error. Resend the write request. It's also
1878 * possible that the page was redirtied so re-clean the page.
1881 cifs_writev_requeue(struct cifs_writedata *wdata)
1884 struct inode *inode = wdata->cfile->dentry->d_inode;
1885 struct TCP_Server_Info *server;
1887 for (i = 0; i < wdata->nr_pages; i++) {
1888 lock_page(wdata->pages[i]);
1889 clear_page_dirty_for_io(wdata->pages[i]);
1893 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1894 rc = server->ops->async_writev(wdata);
1895 } while (rc == -EAGAIN);
1897 for (i = 0; i < wdata->nr_pages; i++) {
1898 unlock_page(wdata->pages[i]);
1900 SetPageError(wdata->pages[i]);
1901 end_page_writeback(wdata->pages[i]);
1902 page_cache_release(wdata->pages[i]);
1906 mapping_set_error(inode->i_mapping, rc);
1907 kref_put(&wdata->refcount, cifs_writedata_release);
1911 cifs_writev_complete(struct work_struct *work)
1913 struct cifs_writedata *wdata = container_of(work,
1914 struct cifs_writedata, work);
1915 struct inode *inode = wdata->cfile->dentry->d_inode;
1918 if (wdata->result == 0) {
1919 spin_lock(&inode->i_lock);
1920 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
1921 spin_unlock(&inode->i_lock);
1922 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
1924 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
1925 return cifs_writev_requeue(wdata);
1927 for (i = 0; i < wdata->nr_pages; i++) {
1928 struct page *page = wdata->pages[i];
1929 if (wdata->result == -EAGAIN)
1930 __set_page_dirty_nobuffers(page);
1931 else if (wdata->result < 0)
1933 end_page_writeback(page);
1934 page_cache_release(page);
1936 if (wdata->result != -EAGAIN)
1937 mapping_set_error(inode->i_mapping, wdata->result);
1938 kref_put(&wdata->refcount, cifs_writedata_release);
1941 struct cifs_writedata *
1942 cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
1944 struct cifs_writedata *wdata;
1946 /* this would overflow */
1947 if (nr_pages == 0) {
1948 cifs_dbg(VFS, "%s: called with nr_pages == 0!\n", __func__);
1952 /* writedata + number of page pointers */
1953 wdata = kzalloc(sizeof(*wdata) +
1954 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
1955 if (wdata != NULL) {
1956 kref_init(&wdata->refcount);
1957 INIT_LIST_HEAD(&wdata->list);
1958 init_completion(&wdata->done);
1959 INIT_WORK(&wdata->work, complete);
1965 * Check the mid_state and signature on received buffer (if any), and queue the
1966 * workqueue completion task.
1969 cifs_writev_callback(struct mid_q_entry *mid)
1971 struct cifs_writedata *wdata = mid->callback_data;
1972 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
1973 unsigned int written;
1974 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
1976 switch (mid->mid_state) {
1977 case MID_RESPONSE_RECEIVED:
1978 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
1979 if (wdata->result != 0)
1982 written = le16_to_cpu(smb->CountHigh);
1984 written += le16_to_cpu(smb->Count);
1986 * Mask off high 16 bits when bytes written as returned
1987 * by the server is greater than bytes requested by the
1988 * client. OS/2 servers are known to set incorrect
1991 if (written > wdata->bytes)
1994 if (written < wdata->bytes)
1995 wdata->result = -ENOSPC;
1997 wdata->bytes = written;
1999 case MID_REQUEST_SUBMITTED:
2000 case MID_RETRY_NEEDED:
2001 wdata->result = -EAGAIN;
2004 wdata->result = -EIO;
2008 queue_work(cifsiod_wq, &wdata->work);
2009 DeleteMidQEntry(mid);
2010 add_credits(tcon->ses->server, 1, 0);
2013 /* cifs_async_writev - send an async write, and set up mid to handle result */
2015 cifs_async_writev(struct cifs_writedata *wdata)
2018 WRITE_REQ *smb = NULL;
2020 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2022 struct smb_rqst rqst = { };
2024 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2028 if (wdata->offset >> 32 > 0) {
2029 /* can not handle big offset for old srv */
2034 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2036 goto async_writev_out;
2038 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2039 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
2041 smb->AndXCommand = 0xFF; /* none */
2042 smb->Fid = wdata->cfile->fid.netfid;
2043 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2045 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2046 smb->Reserved = 0xFFFFFFFF;
2051 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2053 /* 4 for RFC1001 length + 1 for BCC */
2054 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2059 rqst.rq_pages = wdata->pages;
2060 rqst.rq_npages = wdata->nr_pages;
2061 rqst.rq_pagesz = wdata->pagesz;
2062 rqst.rq_tailsz = wdata->tailsz;
2064 cifs_dbg(FYI, "async write at %llu %u bytes\n",
2065 wdata->offset, wdata->bytes);
2067 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2068 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2071 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2072 put_bcc(wdata->bytes + 1, &smb->hdr);
2075 struct smb_com_writex_req *smbw =
2076 (struct smb_com_writex_req *)smb;
2077 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2078 put_bcc(wdata->bytes + 5, &smbw->hdr);
2079 iov.iov_len += 4; /* pad bigger by four bytes */
2082 kref_get(&wdata->refcount);
2083 rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
2084 cifs_writev_callback, wdata, 0);
2087 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2089 kref_put(&wdata->refcount, cifs_writedata_release);
2092 cifs_small_buf_release(smb);
2097 CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
2098 unsigned int *nbytes, struct kvec *iov, int n_vec)
2101 WRITE_REQ *pSMB = NULL;
2104 int resp_buf_type = 0;
2105 __u32 pid = io_parms->pid;
2106 __u16 netfid = io_parms->netfid;
2107 __u64 offset = io_parms->offset;
2108 struct cifs_tcon *tcon = io_parms->tcon;
2109 unsigned int count = io_parms->length;
2113 cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count);
2115 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2119 if ((offset >> 32) > 0) {
2120 /* can not handle big offset for old srv */
2124 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
2128 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2129 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2131 /* tcon and ses pointer are checked in smb_init */
2132 if (tcon->ses->server == NULL)
2133 return -ECONNABORTED;
2135 pSMB->AndXCommand = 0xFF; /* none */
2137 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
2139 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
2140 pSMB->Reserved = 0xFFFFFFFF;
2141 pSMB->WriteMode = 0;
2142 pSMB->Remaining = 0;
2145 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2147 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2148 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
2149 /* header + 1 byte pad */
2150 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
2152 inc_rfc1001_len(pSMB, count + 1);
2153 else /* wct == 12 */
2154 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
2156 pSMB->ByteCount = cpu_to_le16(count + 1);
2157 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2158 struct smb_com_writex_req *pSMBW =
2159 (struct smb_com_writex_req *)pSMB;
2160 pSMBW->ByteCount = cpu_to_le16(count + 5);
2162 iov[0].iov_base = pSMB;
2164 iov[0].iov_len = smb_hdr_len + 4;
2165 else /* wct == 12 pad bigger by four bytes */
2166 iov[0].iov_len = smb_hdr_len + 8;
2169 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0);
2170 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2172 cifs_dbg(FYI, "Send error Write2 = %d\n", rc);
2173 } else if (resp_buf_type == 0) {
2174 /* presumably this can not happen, but best to be safe */
2177 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
2178 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2179 *nbytes = (*nbytes) << 16;
2180 *nbytes += le16_to_cpu(pSMBr->Count);
2183 * Mask off high 16 bits when bytes written as returned by the
2184 * server is greater than bytes requested by the client. OS/2
2185 * servers are known to set incorrect CountHigh values.
2187 if (*nbytes > count)
2191 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2192 if (resp_buf_type == CIFS_SMALL_BUFFER)
2193 cifs_small_buf_release(iov[0].iov_base);
2194 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2195 cifs_buf_release(iov[0].iov_base);
2197 /* Note: On -EAGAIN error only caller can retry on handle based calls
2198 since file handle passed in no longer valid */
2203 int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
2204 const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
2205 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2208 LOCK_REQ *pSMB = NULL;
2213 cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n",
2214 num_lock, num_unlock);
2216 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2221 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2222 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2223 pSMB->LockType = lock_type;
2224 pSMB->AndXCommand = 0xFF; /* none */
2225 pSMB->Fid = netfid; /* netfid stays le */
2227 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2228 inc_rfc1001_len(pSMB, count);
2229 pSMB->ByteCount = cpu_to_le16(count);
2231 iov[0].iov_base = (char *)pSMB;
2232 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2233 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2234 iov[1].iov_base = (char *)buf;
2235 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2237 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2238 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2240 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc);
2246 CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
2247 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
2248 const __u64 offset, const __u32 numUnlock,
2249 const __u32 numLock, const __u8 lockType,
2250 const bool waitFlag, const __u8 oplock_level)
2253 LOCK_REQ *pSMB = NULL;
2254 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2259 cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n",
2260 (int)waitFlag, numLock);
2261 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2266 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
2267 /* no response expected */
2268 flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP;
2270 } else if (waitFlag) {
2271 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2272 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2277 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2278 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2279 pSMB->LockType = lockType;
2280 pSMB->OplockLevel = oplock_level;
2281 pSMB->AndXCommand = 0xFF; /* none */
2282 pSMB->Fid = smb_file_id; /* netfid stays le */
2284 if ((numLock != 0) || (numUnlock != 0)) {
2285 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
2286 /* BB where to store pid high? */
2287 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2288 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2289 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2290 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2291 count = sizeof(LOCKING_ANDX_RANGE);
2296 inc_rfc1001_len(pSMB, count);
2297 pSMB->ByteCount = cpu_to_le16(count);
2300 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2301 (struct smb_hdr *) pSMB, &bytes_returned);
2302 cifs_small_buf_release(pSMB);
2304 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
2305 /* SMB buffer freed by function above */
2307 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2309 cifs_dbg(FYI, "Send error in Lock = %d\n", rc);
2311 /* Note: On -EAGAIN error only caller can retry on handle based calls
2312 since file handle passed in no longer valid */
2317 CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
2318 const __u16 smb_file_id, const __u32 netpid,
2319 const loff_t start_offset, const __u64 len,
2320 struct file_lock *pLockData, const __u16 lock_type,
2321 const bool waitFlag)
2323 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2324 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2325 struct cifs_posix_lock *parm_data;
2328 int bytes_returned = 0;
2329 int resp_buf_type = 0;
2330 __u16 params, param_offset, offset, byte_count, count;
2333 cifs_dbg(FYI, "Posix Lock\n");
2335 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2340 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2343 pSMB->MaxSetupCount = 0;
2346 pSMB->Reserved2 = 0;
2347 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2348 offset = param_offset + params;
2350 count = sizeof(struct cifs_posix_lock);
2351 pSMB->MaxParameterCount = cpu_to_le16(2);
2352 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2353 pSMB->SetupCount = 1;
2354 pSMB->Reserved3 = 0;
2356 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2358 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2359 byte_count = 3 /* pad */ + params + count;
2360 pSMB->DataCount = cpu_to_le16(count);
2361 pSMB->ParameterCount = cpu_to_le16(params);
2362 pSMB->TotalDataCount = pSMB->DataCount;
2363 pSMB->TotalParameterCount = pSMB->ParameterCount;
2364 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2365 parm_data = (struct cifs_posix_lock *)
2366 (((char *) &pSMB->hdr.Protocol) + offset);
2368 parm_data->lock_type = cpu_to_le16(lock_type);
2370 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2371 parm_data->lock_flags = cpu_to_le16(1);
2372 pSMB->Timeout = cpu_to_le32(-1);
2376 parm_data->pid = cpu_to_le32(netpid);
2377 parm_data->start = cpu_to_le64(start_offset);
2378 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
2380 pSMB->DataOffset = cpu_to_le16(offset);
2381 pSMB->Fid = smb_file_id;
2382 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2383 pSMB->Reserved4 = 0;
2384 inc_rfc1001_len(pSMB, byte_count);
2385 pSMB->ByteCount = cpu_to_le16(byte_count);
2387 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2388 (struct smb_hdr *) pSMBr, &bytes_returned);
2390 iov[0].iov_base = (char *)pSMB;
2391 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2392 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2393 &resp_buf_type, timeout);
2394 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2395 not try to free it twice below on exit */
2396 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
2400 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc);
2401 } else if (pLockData) {
2402 /* lock structure can be returned on get */
2405 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2407 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2408 rc = -EIO; /* bad smb */
2411 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2412 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2413 if (data_count < sizeof(struct cifs_posix_lock)) {
2417 parm_data = (struct cifs_posix_lock *)
2418 ((char *)&pSMBr->hdr.Protocol + data_offset);
2419 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
2420 pLockData->fl_type = F_UNLCK;
2422 if (parm_data->lock_type ==
2423 __constant_cpu_to_le16(CIFS_RDLCK))
2424 pLockData->fl_type = F_RDLCK;
2425 else if (parm_data->lock_type ==
2426 __constant_cpu_to_le16(CIFS_WRLCK))
2427 pLockData->fl_type = F_WRLCK;
2429 pLockData->fl_start = le64_to_cpu(parm_data->start);
2430 pLockData->fl_end = pLockData->fl_start +
2431 le64_to_cpu(parm_data->length) - 1;
2432 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
2438 cifs_small_buf_release(pSMB);
2440 if (resp_buf_type == CIFS_SMALL_BUFFER)
2441 cifs_small_buf_release(iov[0].iov_base);
2442 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2443 cifs_buf_release(iov[0].iov_base);
2445 /* Note: On -EAGAIN error only caller can retry on handle based calls
2446 since file handle passed in no longer valid */
2453 CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2456 CLOSE_REQ *pSMB = NULL;
2457 cifs_dbg(FYI, "In CIFSSMBClose\n");
2459 /* do not retry on dead session on close */
2460 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2466 pSMB->FileID = (__u16) smb_file_id;
2467 pSMB->LastWriteTime = 0xFFFFFFFF;
2468 pSMB->ByteCount = 0;
2469 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2470 cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
2473 /* EINTR is expected when user ctl-c to kill app */
2474 cifs_dbg(VFS, "Send error in Close = %d\n", rc);
2478 /* Since session is dead, file will be closed on server already */
2486 CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2489 FLUSH_REQ *pSMB = NULL;
2490 cifs_dbg(FYI, "In CIFSSMBFlush\n");
2492 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2496 pSMB->FileID = (__u16) smb_file_id;
2497 pSMB->ByteCount = 0;
2498 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2499 cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
2501 cifs_dbg(VFS, "Send error in Flush = %d\n", rc);
2507 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
2508 const char *from_name, const char *to_name,
2509 struct cifs_sb_info *cifs_sb)
2512 RENAME_REQ *pSMB = NULL;
2513 RENAME_RSP *pSMBr = NULL;
2515 int name_len, name_len2;
2517 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
2519 cifs_dbg(FYI, "In CIFSSMBRename\n");
2521 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2526 pSMB->BufferFormat = 0x04;
2527 pSMB->SearchAttributes =
2528 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2531 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2532 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2533 from_name, PATH_MAX,
2534 cifs_sb->local_nls, remap);
2535 name_len++; /* trailing null */
2537 pSMB->OldFileName[name_len] = 0x04; /* pad */
2538 /* protocol requires ASCII signature byte on Unicode string */
2539 pSMB->OldFileName[name_len + 1] = 0x00;
2541 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2542 to_name, PATH_MAX, cifs_sb->local_nls,
2544 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2545 name_len2 *= 2; /* convert to bytes */
2546 } else { /* BB improve the check for buffer overruns BB */
2547 name_len = strnlen(from_name, PATH_MAX);
2548 name_len++; /* trailing null */
2549 strncpy(pSMB->OldFileName, from_name, name_len);
2550 name_len2 = strnlen(to_name, PATH_MAX);
2551 name_len2++; /* trailing null */
2552 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2553 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
2554 name_len2++; /* trailing null */
2555 name_len2++; /* signature byte */
2558 count = 1 /* 1st signature byte */ + name_len + name_len2;
2559 inc_rfc1001_len(pSMB, count);
2560 pSMB->ByteCount = cpu_to_le16(count);
2562 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2563 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2564 cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
2566 cifs_dbg(FYI, "Send error in rename = %d\n", rc);
2568 cifs_buf_release(pSMB);
2576 int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
2577 int netfid, const char *target_name,
2578 const struct nls_table *nls_codepage, int remap)
2580 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2581 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2582 struct set_file_rename *rename_info;
2584 char dummy_string[30];
2586 int bytes_returned = 0;
2588 __u16 params, param_offset, offset, count, byte_count;
2590 cifs_dbg(FYI, "Rename to File by handle\n");
2591 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2597 pSMB->MaxSetupCount = 0;
2601 pSMB->Reserved2 = 0;
2602 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2603 offset = param_offset + params;
2605 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2606 rename_info = (struct set_file_rename *) data_offset;
2607 pSMB->MaxParameterCount = cpu_to_le16(2);
2608 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2609 pSMB->SetupCount = 1;
2610 pSMB->Reserved3 = 0;
2611 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2612 byte_count = 3 /* pad */ + params;
2613 pSMB->ParameterCount = cpu_to_le16(params);
2614 pSMB->TotalParameterCount = pSMB->ParameterCount;
2615 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2616 pSMB->DataOffset = cpu_to_le16(offset);
2617 /* construct random name ".cifs_tmp<inodenum><mid>" */
2618 rename_info->overwrite = cpu_to_le32(1);
2619 rename_info->root_fid = 0;
2620 /* unicode only call */
2621 if (target_name == NULL) {
2622 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2624 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2625 dummy_string, 24, nls_codepage, remap);
2628 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2629 target_name, PATH_MAX, nls_codepage,
2632 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2633 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
2634 byte_count += count;
2635 pSMB->DataCount = cpu_to_le16(count);
2636 pSMB->TotalDataCount = pSMB->DataCount;
2638 pSMB->InformationLevel =
2639 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2640 pSMB->Reserved4 = 0;
2641 inc_rfc1001_len(pSMB, byte_count);
2642 pSMB->ByteCount = cpu_to_le16(byte_count);
2643 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2644 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2645 cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
2647 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n",
2650 cifs_buf_release(pSMB);
2652 /* Note: On -EAGAIN error only caller can retry on handle based calls
2653 since file handle passed in no longer valid */
2659 CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
2660 const char *fromName, const __u16 target_tid, const char *toName,
2661 const int flags, const struct nls_table *nls_codepage, int remap)
2664 COPY_REQ *pSMB = NULL;
2665 COPY_RSP *pSMBr = NULL;
2667 int name_len, name_len2;
2670 cifs_dbg(FYI, "In CIFSSMBCopy\n");
2672 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2677 pSMB->BufferFormat = 0x04;
2678 pSMB->Tid2 = target_tid;
2680 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2682 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2683 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2684 fromName, PATH_MAX, nls_codepage,
2686 name_len++; /* trailing null */
2688 pSMB->OldFileName[name_len] = 0x04; /* pad */
2689 /* protocol requires ASCII signature byte on Unicode string */
2690 pSMB->OldFileName[name_len + 1] = 0x00;
2692 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2693 toName, PATH_MAX, nls_codepage, remap);
2694 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2695 name_len2 *= 2; /* convert to bytes */
2696 } else { /* BB improve the check for buffer overruns BB */
2697 name_len = strnlen(fromName, PATH_MAX);
2698 name_len++; /* trailing null */
2699 strncpy(pSMB->OldFileName, fromName, name_len);
2700 name_len2 = strnlen(toName, PATH_MAX);
2701 name_len2++; /* trailing null */
2702 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2703 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2704 name_len2++; /* trailing null */
2705 name_len2++; /* signature byte */
2708 count = 1 /* 1st signature byte */ + name_len + name_len2;
2709 inc_rfc1001_len(pSMB, count);
2710 pSMB->ByteCount = cpu_to_le16(count);
2712 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2713 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2715 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n",
2716 rc, le16_to_cpu(pSMBr->CopyCount));
2718 cifs_buf_release(pSMB);
2727 CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
2728 const char *fromName, const char *toName,
2729 const struct nls_table *nls_codepage)
2731 TRANSACTION2_SPI_REQ *pSMB = NULL;
2732 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2735 int name_len_target;
2737 int bytes_returned = 0;
2738 __u16 params, param_offset, offset, byte_count;
2740 cifs_dbg(FYI, "In Symlink Unix style\n");
2742 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2747 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2749 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2750 /* find define for this maxpathcomponent */
2751 PATH_MAX, nls_codepage);
2752 name_len++; /* trailing null */
2755 } else { /* BB improve the check for buffer overruns BB */
2756 name_len = strnlen(fromName, PATH_MAX);
2757 name_len++; /* trailing null */
2758 strncpy(pSMB->FileName, fromName, name_len);
2760 params = 6 + name_len;
2761 pSMB->MaxSetupCount = 0;
2765 pSMB->Reserved2 = 0;
2766 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2767 InformationLevel) - 4;
2768 offset = param_offset + params;
2770 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2771 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2773 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2774 /* find define for this maxpathcomponent */
2776 name_len_target++; /* trailing null */
2777 name_len_target *= 2;
2778 } else { /* BB improve the check for buffer overruns BB */
2779 name_len_target = strnlen(toName, PATH_MAX);
2780 name_len_target++; /* trailing null */
2781 strncpy(data_offset, toName, name_len_target);
2784 pSMB->MaxParameterCount = cpu_to_le16(2);
2785 /* BB find exact max on data count below from sess */
2786 pSMB->MaxDataCount = cpu_to_le16(1000);
2787 pSMB->SetupCount = 1;
2788 pSMB->Reserved3 = 0;
2789 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2790 byte_count = 3 /* pad */ + params + name_len_target;
2791 pSMB->DataCount = cpu_to_le16(name_len_target);
2792 pSMB->ParameterCount = cpu_to_le16(params);
2793 pSMB->TotalDataCount = pSMB->DataCount;
2794 pSMB->TotalParameterCount = pSMB->ParameterCount;
2795 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2796 pSMB->DataOffset = cpu_to_le16(offset);
2797 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2798 pSMB->Reserved4 = 0;
2799 inc_rfc1001_len(pSMB, byte_count);
2800 pSMB->ByteCount = cpu_to_le16(byte_count);
2801 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2802 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2803 cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
2805 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n",
2808 cifs_buf_release(pSMB);
2811 goto createSymLinkRetry;
2817 CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2818 const char *fromName, const char *toName,
2819 const struct nls_table *nls_codepage, int remap)
2821 TRANSACTION2_SPI_REQ *pSMB = NULL;
2822 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2825 int name_len_target;
2827 int bytes_returned = 0;
2828 __u16 params, param_offset, offset, byte_count;
2830 cifs_dbg(FYI, "In Create Hard link Unix style\n");
2831 createHardLinkRetry:
2832 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2837 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2838 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2839 PATH_MAX, nls_codepage, remap);
2840 name_len++; /* trailing null */
2843 } else { /* BB improve the check for buffer overruns BB */
2844 name_len = strnlen(toName, PATH_MAX);
2845 name_len++; /* trailing null */
2846 strncpy(pSMB->FileName, toName, name_len);
2848 params = 6 + name_len;
2849 pSMB->MaxSetupCount = 0;
2853 pSMB->Reserved2 = 0;
2854 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2855 InformationLevel) - 4;
2856 offset = param_offset + params;
2858 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2859 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2861 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2862 PATH_MAX, nls_codepage, remap);
2863 name_len_target++; /* trailing null */
2864 name_len_target *= 2;
2865 } else { /* BB improve the check for buffer overruns BB */
2866 name_len_target = strnlen(fromName, PATH_MAX);
2867 name_len_target++; /* trailing null */
2868 strncpy(data_offset, fromName, name_len_target);
2871 pSMB->MaxParameterCount = cpu_to_le16(2);
2872 /* BB find exact max on data count below from sess*/
2873 pSMB->MaxDataCount = cpu_to_le16(1000);
2874 pSMB->SetupCount = 1;
2875 pSMB->Reserved3 = 0;
2876 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2877 byte_count = 3 /* pad */ + params + name_len_target;
2878 pSMB->ParameterCount = cpu_to_le16(params);
2879 pSMB->TotalParameterCount = pSMB->ParameterCount;
2880 pSMB->DataCount = cpu_to_le16(name_len_target);
2881 pSMB->TotalDataCount = pSMB->DataCount;
2882 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2883 pSMB->DataOffset = cpu_to_le16(offset);
2884 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2885 pSMB->Reserved4 = 0;
2886 inc_rfc1001_len(pSMB, byte_count);
2887 pSMB->ByteCount = cpu_to_le16(byte_count);
2888 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2889 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2890 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2892 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n",
2895 cifs_buf_release(pSMB);
2897 goto createHardLinkRetry;
2903 CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2904 const char *from_name, const char *to_name,
2905 struct cifs_sb_info *cifs_sb)
2908 NT_RENAME_REQ *pSMB = NULL;
2909 RENAME_RSP *pSMBr = NULL;
2911 int name_len, name_len2;
2913 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
2915 cifs_dbg(FYI, "In CIFSCreateHardLink\n");
2916 winCreateHardLinkRetry:
2918 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2923 pSMB->SearchAttributes =
2924 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2926 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2927 pSMB->ClusterCount = 0;
2929 pSMB->BufferFormat = 0x04;
2931 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2933 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
2934 PATH_MAX, cifs_sb->local_nls, remap);
2935 name_len++; /* trailing null */
2938 /* protocol specifies ASCII buffer format (0x04) for unicode */
2939 pSMB->OldFileName[name_len] = 0x04;
2940 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
2942 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2943 to_name, PATH_MAX, cifs_sb->local_nls,
2945 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2946 name_len2 *= 2; /* convert to bytes */
2947 } else { /* BB improve the check for buffer overruns BB */
2948 name_len = strnlen(from_name, PATH_MAX);
2949 name_len++; /* trailing null */
2950 strncpy(pSMB->OldFileName, from_name, name_len);
2951 name_len2 = strnlen(to_name, PATH_MAX);
2952 name_len2++; /* trailing null */
2953 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2954 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
2955 name_len2++; /* trailing null */
2956 name_len2++; /* signature byte */
2959 count = 1 /* string type byte */ + name_len + name_len2;
2960 inc_rfc1001_len(pSMB, count);
2961 pSMB->ByteCount = cpu_to_le16(count);
2963 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2964 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2965 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2967 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
2969 cifs_buf_release(pSMB);
2971 goto winCreateHardLinkRetry;
2977 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
2978 const unsigned char *searchName, char **symlinkinfo,
2979 const struct nls_table *nls_codepage)
2981 /* SMB_QUERY_FILE_UNIX_LINK */
2982 TRANSACTION2_QPI_REQ *pSMB = NULL;
2983 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2987 __u16 params, byte_count;
2990 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
2993 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2998 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3000 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3001 PATH_MAX, nls_codepage);
3002 name_len++; /* trailing null */
3004 } else { /* BB improve the check for buffer overruns BB */
3005 name_len = strnlen(searchName, PATH_MAX);
3006 name_len++; /* trailing null */
3007 strncpy(pSMB->FileName, searchName, name_len);
3010 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3011 pSMB->TotalDataCount = 0;
3012 pSMB->MaxParameterCount = cpu_to_le16(2);
3013 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3014 pSMB->MaxSetupCount = 0;
3018 pSMB->Reserved2 = 0;
3019 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3020 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3021 pSMB->DataCount = 0;
3022 pSMB->DataOffset = 0;
3023 pSMB->SetupCount = 1;
3024 pSMB->Reserved3 = 0;
3025 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3026 byte_count = params + 1 /* pad */ ;
3027 pSMB->TotalParameterCount = cpu_to_le16(params);
3028 pSMB->ParameterCount = pSMB->TotalParameterCount;
3029 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3030 pSMB->Reserved4 = 0;
3031 inc_rfc1001_len(pSMB, byte_count);
3032 pSMB->ByteCount = cpu_to_le16(byte_count);
3034 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3035 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3037 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
3039 /* decode response */
3041 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3042 /* BB also check enough total bytes returned */
3043 if (rc || get_bcc(&pSMBr->hdr) < 2)
3047 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3049 data_start = ((char *) &pSMBr->hdr.Protocol) +
3050 le16_to_cpu(pSMBr->t2.DataOffset);
3052 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3057 /* BB FIXME investigate remapping reserved chars here */
3058 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3059 count, is_unicode, nls_codepage);
3064 cifs_buf_release(pSMB);
3066 goto querySymLinkRetry;
3071 * Recent Windows versions now create symlinks more frequently
3072 * and they use the "reparse point" mechanism below. We can of course
3073 * do symlinks nicely to Samba and other servers which support the
3074 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3075 * "MF" symlinks optionally, but for recent Windows we really need to
3076 * reenable the code below and fix the cifs_symlink callers to handle this.
3077 * In the interim this code has been moved to its own config option so
3078 * it is not compiled in by default until callers fixed up and more tested.
3081 CIFSSMBQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3082 __u16 fid, char **symlinkinfo,
3083 const struct nls_table *nls_codepage)
3087 struct smb_com_transaction_ioctl_req *pSMB;
3088 struct smb_com_transaction_ioctl_rsp *pSMBr;
3090 unsigned int sub_len;
3092 struct reparse_data *reparse_buf;
3093 __u32 data_offset, data_count;
3096 cifs_dbg(FYI, "In Windows reparse style QueryLink for fid %u\n", fid);
3097 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3102 pSMB->TotalParameterCount = 0 ;
3103 pSMB->TotalDataCount = 0;
3104 pSMB->MaxParameterCount = cpu_to_le32(2);
3105 /* BB find exact data count max from sess structure BB */
3106 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3107 pSMB->MaxSetupCount = 4;
3109 pSMB->ParameterOffset = 0;
3110 pSMB->DataCount = 0;
3111 pSMB->DataOffset = 0;
3112 pSMB->SetupCount = 4;
3113 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3114 pSMB->ParameterCount = pSMB->TotalParameterCount;
3115 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3116 pSMB->IsFsctl = 1; /* FSCTL */
3117 pSMB->IsRootFlag = 0;
3118 pSMB->Fid = fid; /* file handle always le */
3119 pSMB->ByteCount = 0;
3121 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3122 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3124 cifs_dbg(FYI, "Send error in QueryReparseLinkInfo = %d\n", rc);
3128 data_offset = le32_to_cpu(pSMBr->DataOffset);
3129 data_count = le32_to_cpu(pSMBr->DataCount);
3130 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3131 /* BB also check enough total bytes returned */
3132 rc = -EIO; /* bad smb */
3135 if (!data_count || (data_count > 2048)) {
3137 cifs_dbg(FYI, "Invalid return data count on get reparse info ioctl\n");
3140 end_of_smb = 2 + get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
3141 reparse_buf = (struct reparse_data *)
3142 ((char *)&pSMBr->hdr.Protocol + data_offset);
3143 if ((char *)reparse_buf >= end_of_smb) {
3147 if ((reparse_buf->PathBuffer + reparse_buf->PrintNameOffset +
3148 reparse_buf->PrintNameLength) > end_of_smb) {
3149 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3153 sub_start = reparse_buf->SubstituteNameOffset + reparse_buf->PathBuffer;
3154 sub_len = reparse_buf->SubstituteNameLength;
3155 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3160 /* BB FIXME investigate remapping reserved chars here */
3161 *symlinkinfo = cifs_strndup_from_utf16(sub_start, sub_len, is_unicode,
3166 cifs_buf_release(pSMB);
3169 * Note: On -EAGAIN error only caller can retry on handle based calls
3170 * since file handle passed in no longer valid.
3175 #ifdef CONFIG_CIFS_POSIX
3177 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3178 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3179 struct cifs_posix_ace *cifs_ace)
3181 /* u8 cifs fields do not need le conversion */
3182 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3183 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3184 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
3186 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3187 ace->e_perm, ace->e_tag, ace->e_id);
3193 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3194 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3195 const int acl_type, const int size_of_data_area)
3200 struct cifs_posix_ace *pACE;
3201 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3202 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
3204 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3207 if (acl_type & ACL_TYPE_ACCESS) {
3208 count = le16_to_cpu(cifs_acl->access_entry_count);
3209 pACE = &cifs_acl->ace_array[0];
3210 size = sizeof(struct cifs_posix_acl);
3211 size += sizeof(struct cifs_posix_ace) * count;
3212 /* check if we would go beyond end of SMB */
3213 if (size_of_data_area < size) {
3214 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
3215 size_of_data_area, size);
3218 } else if (acl_type & ACL_TYPE_DEFAULT) {
3219 count = le16_to_cpu(cifs_acl->access_entry_count);
3220 size = sizeof(struct cifs_posix_acl);
3221 size += sizeof(struct cifs_posix_ace) * count;
3222 /* skip past access ACEs to get to default ACEs */
3223 pACE = &cifs_acl->ace_array[count];
3224 count = le16_to_cpu(cifs_acl->default_entry_count);
3225 size += sizeof(struct cifs_posix_ace) * count;
3226 /* check if we would go beyond end of SMB */
3227 if (size_of_data_area < size)
3234 size = posix_acl_xattr_size(count);
3235 if ((buflen == 0) || (local_acl == NULL)) {
3236 /* used to query ACL EA size */
3237 } else if (size > buflen) {
3239 } else /* buffer big enough */ {
3240 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
3241 for (i = 0; i < count ; i++) {
3242 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3249 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3250 const posix_acl_xattr_entry *local_ace)
3252 __u16 rc = 0; /* 0 = ACL converted ok */
3254 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3255 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
3256 /* BB is there a better way to handle the large uid? */
3257 if (local_ace->e_id == cpu_to_le32(-1)) {
3258 /* Probably no need to le convert -1 on any arch but can not hurt */
3259 cifs_ace->cifs_uid = cpu_to_le64(-1);
3261 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
3263 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3264 ace->e_perm, ace->e_tag, ace->e_id);
3269 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3270 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3271 const int buflen, const int acl_type)
3274 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3275 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
3279 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
3282 count = posix_acl_xattr_count((size_t)buflen);
3283 cifs_dbg(FYI, "setting acl with %d entries from buf of length %d and version of %d\n",
3284 count, buflen, le32_to_cpu(local_acl->a_version));
3285 if (le32_to_cpu(local_acl->a_version) != 2) {
3286 cifs_dbg(FYI, "unknown POSIX ACL version %d\n",
3287 le32_to_cpu(local_acl->a_version));
3290 cifs_acl->version = cpu_to_le16(1);
3291 if (acl_type == ACL_TYPE_ACCESS)
3292 cifs_acl->access_entry_count = cpu_to_le16(count);
3293 else if (acl_type == ACL_TYPE_DEFAULT)
3294 cifs_acl->default_entry_count = cpu_to_le16(count);
3296 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
3299 for (i = 0; i < count; i++) {
3300 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3301 &local_acl->a_entries[i]);
3303 /* ACE not converted */
3308 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3309 rc += sizeof(struct cifs_posix_acl);
3310 /* BB add check to make sure ACL does not overflow SMB */
3316 CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3317 const unsigned char *searchName,
3318 char *acl_inf, const int buflen, const int acl_type,
3319 const struct nls_table *nls_codepage, int remap)
3321 /* SMB_QUERY_POSIX_ACL */
3322 TRANSACTION2_QPI_REQ *pSMB = NULL;
3323 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3327 __u16 params, byte_count;
3329 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
3332 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3337 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3339 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3340 searchName, PATH_MAX, nls_codepage,
3342 name_len++; /* trailing null */
3344 pSMB->FileName[name_len] = 0;
3345 pSMB->FileName[name_len+1] = 0;
3346 } else { /* BB improve the check for buffer overruns BB */
3347 name_len = strnlen(searchName, PATH_MAX);
3348 name_len++; /* trailing null */
3349 strncpy(pSMB->FileName, searchName, name_len);
3352 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3353 pSMB->TotalDataCount = 0;
3354 pSMB->MaxParameterCount = cpu_to_le16(2);
3355 /* BB find exact max data count below from sess structure BB */
3356 pSMB->MaxDataCount = cpu_to_le16(4000);
3357 pSMB->MaxSetupCount = 0;
3361 pSMB->Reserved2 = 0;
3362 pSMB->ParameterOffset = cpu_to_le16(
3363 offsetof(struct smb_com_transaction2_qpi_req,
3364 InformationLevel) - 4);
3365 pSMB->DataCount = 0;
3366 pSMB->DataOffset = 0;
3367 pSMB->SetupCount = 1;
3368 pSMB->Reserved3 = 0;
3369 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3370 byte_count = params + 1 /* pad */ ;
3371 pSMB->TotalParameterCount = cpu_to_le16(params);
3372 pSMB->ParameterCount = pSMB->TotalParameterCount;
3373 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3374 pSMB->Reserved4 = 0;
3375 inc_rfc1001_len(pSMB, byte_count);
3376 pSMB->ByteCount = cpu_to_le16(byte_count);
3378 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3379 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3380 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3382 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
3384 /* decode response */
3386 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3387 /* BB also check enough total bytes returned */
3388 if (rc || get_bcc(&pSMBr->hdr) < 2)
3389 rc = -EIO; /* bad smb */
3391 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3392 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3393 rc = cifs_copy_posix_acl(acl_inf,
3394 (char *)&pSMBr->hdr.Protocol+data_offset,
3395 buflen, acl_type, count);
3398 cifs_buf_release(pSMB);
3405 CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3406 const unsigned char *fileName,
3407 const char *local_acl, const int buflen,
3409 const struct nls_table *nls_codepage, int remap)
3411 struct smb_com_transaction2_spi_req *pSMB = NULL;
3412 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3416 int bytes_returned = 0;
3417 __u16 params, byte_count, data_count, param_offset, offset;
3419 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
3421 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3425 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3427 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3428 PATH_MAX, nls_codepage, remap);
3429 name_len++; /* trailing null */
3431 } else { /* BB improve the check for buffer overruns BB */
3432 name_len = strnlen(fileName, PATH_MAX);
3433 name_len++; /* trailing null */
3434 strncpy(pSMB->FileName, fileName, name_len);
3436 params = 6 + name_len;
3437 pSMB->MaxParameterCount = cpu_to_le16(2);
3438 /* BB find max SMB size from sess */
3439 pSMB->MaxDataCount = cpu_to_le16(1000);
3440 pSMB->MaxSetupCount = 0;
3444 pSMB->Reserved2 = 0;
3445 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3446 InformationLevel) - 4;
3447 offset = param_offset + params;
3448 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3449 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3451 /* convert to on the wire format for POSIX ACL */
3452 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
3454 if (data_count == 0) {
3456 goto setACLerrorExit;
3458 pSMB->DataOffset = cpu_to_le16(offset);
3459 pSMB->SetupCount = 1;
3460 pSMB->Reserved3 = 0;
3461 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3462 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3463 byte_count = 3 /* pad */ + params + data_count;
3464 pSMB->DataCount = cpu_to_le16(data_count);
3465 pSMB->TotalDataCount = pSMB->DataCount;
3466 pSMB->ParameterCount = cpu_to_le16(params);
3467 pSMB->TotalParameterCount = pSMB->ParameterCount;
3468 pSMB->Reserved4 = 0;
3469 inc_rfc1001_len(pSMB, byte_count);
3470 pSMB->ByteCount = cpu_to_le16(byte_count);
3471 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3472 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3474 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
3477 cifs_buf_release(pSMB);
3483 /* BB fix tabs in this function FIXME BB */
3485 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
3486 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3489 struct smb_t2_qfi_req *pSMB = NULL;
3490 struct smb_t2_qfi_rsp *pSMBr = NULL;
3492 __u16 params, byte_count;
3494 cifs_dbg(FYI, "In GetExtAttr\n");
3499 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3504 params = 2 /* level */ + 2 /* fid */;
3505 pSMB->t2.TotalDataCount = 0;
3506 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3507 /* BB find exact max data count below from sess structure BB */
3508 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3509 pSMB->t2.MaxSetupCount = 0;
3510 pSMB->t2.Reserved = 0;
3512 pSMB->t2.Timeout = 0;
3513 pSMB->t2.Reserved2 = 0;
3514 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3516 pSMB->t2.DataCount = 0;
3517 pSMB->t2.DataOffset = 0;
3518 pSMB->t2.SetupCount = 1;
3519 pSMB->t2.Reserved3 = 0;
3520 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3521 byte_count = params + 1 /* pad */ ;
3522 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3523 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3524 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3527 inc_rfc1001_len(pSMB, byte_count);
3528 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3530 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3531 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3533 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
3535 /* decode response */
3536 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3537 /* BB also check enough total bytes returned */
3538 if (rc || get_bcc(&pSMBr->hdr) < 2)
3539 /* If rc should we check for EOPNOSUPP and
3540 disable the srvino flag? or in caller? */
3541 rc = -EIO; /* bad smb */
3543 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3544 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3545 struct file_chattr_info *pfinfo;
3546 /* BB Do we need a cast or hash here ? */
3548 cifs_dbg(FYI, "Illegal size ret in GetExtAttr\n");
3552 pfinfo = (struct file_chattr_info *)
3553 (data_offset + (char *) &pSMBr->hdr.Protocol);
3554 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3555 *pMask = le64_to_cpu(pfinfo->mask);
3559 cifs_buf_release(pSMB);
3561 goto GetExtAttrRetry;
3565 #endif /* CONFIG_POSIX */
3567 #ifdef CONFIG_CIFS_ACL
3569 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3570 * all NT TRANSACTS that we init here have total parm and data under about 400
3571 * bytes (to fit in small cifs buffer size), which is the case so far, it
3572 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3573 * returned setup area) and MaxParameterCount (returned parms size) must be set
3577 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3578 const int parm_len, struct cifs_tcon *tcon,
3583 struct smb_com_ntransact_req *pSMB;
3585 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3589 *ret_buf = (void *)pSMB;
3591 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3592 pSMB->TotalDataCount = 0;
3593 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3594 pSMB->ParameterCount = pSMB->TotalParameterCount;
3595 pSMB->DataCount = pSMB->TotalDataCount;
3596 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3597 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3598 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3599 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3600 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3601 pSMB->SubCommand = cpu_to_le16(sub_command);
3606 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3607 __u32 *pparmlen, __u32 *pdatalen)
3610 __u32 data_count, data_offset, parm_count, parm_offset;
3611 struct smb_com_ntransact_rsp *pSMBr;
3620 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3622 bcc = get_bcc(&pSMBr->hdr);
3623 end_of_smb = 2 /* sizeof byte count */ + bcc +
3624 (char *)&pSMBr->ByteCount;
3626 data_offset = le32_to_cpu(pSMBr->DataOffset);
3627 data_count = le32_to_cpu(pSMBr->DataCount);
3628 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3629 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3631 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3632 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3634 /* should we also check that parm and data areas do not overlap? */
3635 if (*ppparm > end_of_smb) {
3636 cifs_dbg(FYI, "parms start after end of smb\n");
3638 } else if (parm_count + *ppparm > end_of_smb) {
3639 cifs_dbg(FYI, "parm end after end of smb\n");
3641 } else if (*ppdata > end_of_smb) {
3642 cifs_dbg(FYI, "data starts after end of smb\n");
3644 } else if (data_count + *ppdata > end_of_smb) {
3645 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3646 *ppdata, data_count, (data_count + *ppdata),
3649 } else if (parm_count + data_count > bcc) {
3650 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
3653 *pdatalen = data_count;
3654 *pparmlen = parm_count;
3658 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3660 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3661 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3665 QUERY_SEC_DESC_REQ *pSMB;
3668 cifs_dbg(FYI, "GetCifsACL\n");
3673 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3674 8 /* parm len */, tcon, (void **) &pSMB);
3678 pSMB->MaxParameterCount = cpu_to_le32(4);
3679 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3680 pSMB->MaxSetupCount = 0;
3681 pSMB->Fid = fid; /* file handle always le */
3682 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3684 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3685 inc_rfc1001_len(pSMB, 11);
3686 iov[0].iov_base = (char *)pSMB;
3687 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3689 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3691 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3693 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
3694 } else { /* decode response */
3698 struct smb_com_ntransact_rsp *pSMBr;
3701 /* validate_nttransact */
3702 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3703 &pdata, &parm_len, pbuflen);
3706 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3708 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3709 pSMBr, parm, *acl_inf);
3711 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3712 rc = -EIO; /* bad smb */
3717 /* BB check that data area is minimum length and as big as acl_len */
3719 acl_len = le32_to_cpu(*parm);
3720 if (acl_len != *pbuflen) {
3721 cifs_dbg(VFS, "acl length %d does not match %d\n",
3723 if (*pbuflen > acl_len)
3727 /* check if buffer is big enough for the acl
3728 header followed by the smallest SID */
3729 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3730 (*pbuflen >= 64 * 1024)) {
3731 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
3735 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
3736 if (*acl_inf == NULL) {
3743 if (buf_type == CIFS_SMALL_BUFFER)
3744 cifs_small_buf_release(iov[0].iov_base);
3745 else if (buf_type == CIFS_LARGE_BUFFER)
3746 cifs_buf_release(iov[0].iov_base);
3747 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3752 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3753 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3755 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3757 int bytes_returned = 0;
3758 SET_SEC_DESC_REQ *pSMB = NULL;
3762 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
3766 pSMB->MaxSetupCount = 0;
3770 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3771 data_count = acllen;
3772 data_offset = param_offset + param_count;
3773 byte_count = 3 /* pad */ + param_count;
3775 pSMB->DataCount = cpu_to_le32(data_count);
3776 pSMB->TotalDataCount = pSMB->DataCount;
3777 pSMB->MaxParameterCount = cpu_to_le32(4);
3778 pSMB->MaxDataCount = cpu_to_le32(16384);
3779 pSMB->ParameterCount = cpu_to_le32(param_count);
3780 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3781 pSMB->TotalParameterCount = pSMB->ParameterCount;
3782 pSMB->DataOffset = cpu_to_le32(data_offset);
3783 pSMB->SetupCount = 0;
3784 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3785 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3787 pSMB->Fid = fid; /* file handle always le */
3788 pSMB->Reserved2 = 0;
3789 pSMB->AclFlags = cpu_to_le32(aclflag);
3791 if (pntsd && acllen) {
3792 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
3793 data_offset, pntsd, acllen);
3794 inc_rfc1001_len(pSMB, byte_count + data_count);
3796 inc_rfc1001_len(pSMB, byte_count);
3798 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3799 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3801 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3802 bytes_returned, rc);
3804 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
3805 cifs_buf_release(pSMB);
3808 goto setCifsAclRetry;
3813 #endif /* CONFIG_CIFS_ACL */
3815 /* Legacy Query Path Information call for lookup to old servers such
3818 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
3819 const char *search_name, FILE_ALL_INFO *data,
3820 const struct nls_table *nls_codepage, int remap)
3822 QUERY_INFORMATION_REQ *pSMB;
3823 QUERY_INFORMATION_RSP *pSMBr;
3828 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
3830 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3835 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3837 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3838 search_name, PATH_MAX, nls_codepage,
3840 name_len++; /* trailing null */
3843 name_len = strnlen(search_name, PATH_MAX);
3844 name_len++; /* trailing null */
3845 strncpy(pSMB->FileName, search_name, name_len);
3847 pSMB->BufferFormat = 0x04;
3848 name_len++; /* account for buffer type byte */
3849 inc_rfc1001_len(pSMB, (__u16)name_len);
3850 pSMB->ByteCount = cpu_to_le16(name_len);
3852 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3853 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3855 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
3858 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3860 /* decode response */
3861 /* BB FIXME - add time zone adjustment BB */
3862 memset(data, 0, sizeof(FILE_ALL_INFO));
3865 /* decode time fields */
3866 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3867 data->LastWriteTime = data->ChangeTime;
3868 data->LastAccessTime = 0;
3869 data->AllocationSize =
3870 cpu_to_le64(le32_to_cpu(pSMBr->size));
3871 data->EndOfFile = data->AllocationSize;
3873 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3875 rc = -EIO; /* bad buffer passed in */
3877 cifs_buf_release(pSMB);
3886 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
3887 u16 netfid, FILE_ALL_INFO *pFindData)
3889 struct smb_t2_qfi_req *pSMB = NULL;
3890 struct smb_t2_qfi_rsp *pSMBr = NULL;
3893 __u16 params, byte_count;
3896 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3901 params = 2 /* level */ + 2 /* fid */;
3902 pSMB->t2.TotalDataCount = 0;
3903 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3904 /* BB find exact max data count below from sess structure BB */
3905 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3906 pSMB->t2.MaxSetupCount = 0;
3907 pSMB->t2.Reserved = 0;
3909 pSMB->t2.Timeout = 0;
3910 pSMB->t2.Reserved2 = 0;
3911 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3913 pSMB->t2.DataCount = 0;
3914 pSMB->t2.DataOffset = 0;
3915 pSMB->t2.SetupCount = 1;
3916 pSMB->t2.Reserved3 = 0;
3917 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3918 byte_count = params + 1 /* pad */ ;
3919 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3920 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3921 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3924 inc_rfc1001_len(pSMB, byte_count);
3925 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3927 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3928 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3930 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
3931 } else { /* decode response */
3932 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3934 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3936 else if (get_bcc(&pSMBr->hdr) < 40)
3937 rc = -EIO; /* bad smb */
3938 else if (pFindData) {
3939 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3940 memcpy((char *) pFindData,
3941 (char *) &pSMBr->hdr.Protocol +
3942 data_offset, sizeof(FILE_ALL_INFO));
3946 cifs_buf_release(pSMB);
3948 goto QFileInfoRetry;
3954 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
3955 const char *search_name, FILE_ALL_INFO *data,
3956 int legacy /* old style infolevel */,
3957 const struct nls_table *nls_codepage, int remap)
3959 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3960 TRANSACTION2_QPI_REQ *pSMB = NULL;
3961 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3965 __u16 params, byte_count;
3967 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
3969 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3974 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3976 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
3977 PATH_MAX, nls_codepage, remap);
3978 name_len++; /* trailing null */
3980 } else { /* BB improve the check for buffer overruns BB */
3981 name_len = strnlen(search_name, PATH_MAX);
3982 name_len++; /* trailing null */
3983 strncpy(pSMB->FileName, search_name, name_len);
3986 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3987 pSMB->TotalDataCount = 0;
3988 pSMB->MaxParameterCount = cpu_to_le16(2);
3989 /* BB find exact max SMB PDU from sess structure BB */
3990 pSMB->MaxDataCount = cpu_to_le16(4000);
3991 pSMB->MaxSetupCount = 0;
3995 pSMB->Reserved2 = 0;
3996 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3997 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3998 pSMB->DataCount = 0;
3999 pSMB->DataOffset = 0;
4000 pSMB->SetupCount = 1;
4001 pSMB->Reserved3 = 0;
4002 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4003 byte_count = params + 1 /* pad */ ;
4004 pSMB->TotalParameterCount = cpu_to_le16(params);
4005 pSMB->ParameterCount = pSMB->TotalParameterCount;
4007 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4009 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4010 pSMB->Reserved4 = 0;
4011 inc_rfc1001_len(pSMB, byte_count);
4012 pSMB->ByteCount = cpu_to_le16(byte_count);
4014 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4015 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4017 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
4018 } else { /* decode response */
4019 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4021 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4023 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
4024 rc = -EIO; /* bad smb */
4025 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
4026 rc = -EIO; /* 24 or 26 expected but we do not read
4030 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4033 * On legacy responses we do not read the last field,
4034 * EAsize, fortunately since it varies by subdialect and
4035 * also note it differs on Set vs Get, ie two bytes or 4
4036 * bytes depending but we don't care here.
4039 size = sizeof(FILE_INFO_STANDARD);
4041 size = sizeof(FILE_ALL_INFO);
4042 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
4047 cifs_buf_release(pSMB);
4049 goto QPathInfoRetry;
4055 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
4056 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4058 struct smb_t2_qfi_req *pSMB = NULL;
4059 struct smb_t2_qfi_rsp *pSMBr = NULL;
4062 __u16 params, byte_count;
4065 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4070 params = 2 /* level */ + 2 /* fid */;
4071 pSMB->t2.TotalDataCount = 0;
4072 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4073 /* BB find exact max data count below from sess structure BB */
4074 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4075 pSMB->t2.MaxSetupCount = 0;
4076 pSMB->t2.Reserved = 0;
4078 pSMB->t2.Timeout = 0;
4079 pSMB->t2.Reserved2 = 0;
4080 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4082 pSMB->t2.DataCount = 0;
4083 pSMB->t2.DataOffset = 0;
4084 pSMB->t2.SetupCount = 1;
4085 pSMB->t2.Reserved3 = 0;
4086 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4087 byte_count = params + 1 /* pad */ ;
4088 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4089 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4090 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4093 inc_rfc1001_len(pSMB, byte_count);
4094 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
4096 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4097 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4099 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
4100 } else { /* decode response */
4101 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4103 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4104 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4105 rc = -EIO; /* bad smb */
4107 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4108 memcpy((char *) pFindData,
4109 (char *) &pSMBr->hdr.Protocol +
4111 sizeof(FILE_UNIX_BASIC_INFO));
4115 cifs_buf_release(pSMB);
4117 goto UnixQFileInfoRetry;
4123 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
4124 const unsigned char *searchName,
4125 FILE_UNIX_BASIC_INFO *pFindData,
4126 const struct nls_table *nls_codepage, int remap)
4128 /* SMB_QUERY_FILE_UNIX_BASIC */
4129 TRANSACTION2_QPI_REQ *pSMB = NULL;
4130 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4132 int bytes_returned = 0;
4134 __u16 params, byte_count;
4136 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
4138 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4143 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4145 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4146 PATH_MAX, nls_codepage, remap);
4147 name_len++; /* trailing null */
4149 } else { /* BB improve the check for buffer overruns BB */
4150 name_len = strnlen(searchName, PATH_MAX);
4151 name_len++; /* trailing null */
4152 strncpy(pSMB->FileName, searchName, name_len);
4155 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4156 pSMB->TotalDataCount = 0;
4157 pSMB->MaxParameterCount = cpu_to_le16(2);
4158 /* BB find exact max SMB PDU from sess structure BB */
4159 pSMB->MaxDataCount = cpu_to_le16(4000);
4160 pSMB->MaxSetupCount = 0;
4164 pSMB->Reserved2 = 0;
4165 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4166 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4167 pSMB->DataCount = 0;
4168 pSMB->DataOffset = 0;
4169 pSMB->SetupCount = 1;
4170 pSMB->Reserved3 = 0;
4171 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4172 byte_count = params + 1 /* pad */ ;
4173 pSMB->TotalParameterCount = cpu_to_le16(params);
4174 pSMB->ParameterCount = pSMB->TotalParameterCount;
4175 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4176 pSMB->Reserved4 = 0;
4177 inc_rfc1001_len(pSMB, byte_count);
4178 pSMB->ByteCount = cpu_to_le16(byte_count);
4180 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4181 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4183 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
4184 } else { /* decode response */
4185 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4187 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4188 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4189 rc = -EIO; /* bad smb */
4191 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4192 memcpy((char *) pFindData,
4193 (char *) &pSMBr->hdr.Protocol +
4195 sizeof(FILE_UNIX_BASIC_INFO));
4198 cifs_buf_release(pSMB);
4200 goto UnixQPathInfoRetry;
4205 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4207 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
4208 const char *searchName, struct cifs_sb_info *cifs_sb,
4209 __u16 *pnetfid, __u16 search_flags,
4210 struct cifs_search_info *psrch_inf, bool msearch)
4212 /* level 257 SMB_ */
4213 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4214 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
4215 T2_FFIRST_RSP_PARMS *parms;
4217 int bytes_returned = 0;
4218 int name_len, remap;
4219 __u16 params, byte_count;
4220 struct nls_table *nls_codepage;
4222 cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
4225 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4230 nls_codepage = cifs_sb->local_nls;
4231 remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
4233 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4235 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4236 PATH_MAX, nls_codepage, remap);
4237 /* We can not add the asterik earlier in case
4238 it got remapped to 0xF03A as if it were part of the
4239 directory name instead of a wildcard */
4242 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4243 pSMB->FileName[name_len+1] = 0;
4244 pSMB->FileName[name_len+2] = '*';
4245 pSMB->FileName[name_len+3] = 0;
4246 name_len += 4; /* now the trailing null */
4247 /* null terminate just in case */
4248 pSMB->FileName[name_len] = 0;
4249 pSMB->FileName[name_len+1] = 0;
4252 } else { /* BB add check for overrun of SMB buf BB */
4253 name_len = strnlen(searchName, PATH_MAX);
4254 /* BB fix here and in unicode clause above ie
4255 if (name_len > buffersize-header)
4256 free buffer exit; BB */
4257 strncpy(pSMB->FileName, searchName, name_len);
4259 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4260 pSMB->FileName[name_len+1] = '*';
4261 pSMB->FileName[name_len+2] = 0;
4266 params = 12 + name_len /* includes null */ ;
4267 pSMB->TotalDataCount = 0; /* no EAs */
4268 pSMB->MaxParameterCount = cpu_to_le16(10);
4269 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4270 pSMB->MaxSetupCount = 0;
4274 pSMB->Reserved2 = 0;
4275 byte_count = params + 1 /* pad */ ;
4276 pSMB->TotalParameterCount = cpu_to_le16(params);
4277 pSMB->ParameterCount = pSMB->TotalParameterCount;
4278 pSMB->ParameterOffset = cpu_to_le16(
4279 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4281 pSMB->DataCount = 0;
4282 pSMB->DataOffset = 0;
4283 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4284 pSMB->Reserved3 = 0;
4285 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4286 pSMB->SearchAttributes =
4287 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4289 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4290 pSMB->SearchFlags = cpu_to_le16(search_flags);
4291 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4293 /* BB what should we set StorageType to? Does it matter? BB */
4294 pSMB->SearchStorageType = 0;
4295 inc_rfc1001_len(pSMB, byte_count);
4296 pSMB->ByteCount = cpu_to_le16(byte_count);
4298 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4299 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4300 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
4302 if (rc) {/* BB add logic to retry regular search if Unix search
4303 rejected unexpectedly by server */
4304 /* BB Add code to handle unsupported level rc */
4305 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
4307 cifs_buf_release(pSMB);
4309 /* BB eventually could optimize out free and realloc of buf */
4312 goto findFirstRetry;
4313 } else { /* decode response */
4314 /* BB remember to free buffer if error BB */
4315 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4319 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4320 psrch_inf->unicode = true;
4322 psrch_inf->unicode = false;
4324 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4325 psrch_inf->smallBuf = 0;
4326 psrch_inf->srch_entries_start =
4327 (char *) &pSMBr->hdr.Protocol +
4328 le16_to_cpu(pSMBr->t2.DataOffset);
4329 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4330 le16_to_cpu(pSMBr->t2.ParameterOffset));
4332 if (parms->EndofSearch)
4333 psrch_inf->endOfSearch = true;
4335 psrch_inf->endOfSearch = false;
4337 psrch_inf->entries_in_buffer =
4338 le16_to_cpu(parms->SearchCount);
4339 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4340 psrch_inf->entries_in_buffer;
4341 lnoff = le16_to_cpu(parms->LastNameOffset);
4342 if (CIFSMaxBufSize < lnoff) {
4343 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4344 psrch_inf->last_entry = NULL;
4348 psrch_inf->last_entry = psrch_inf->srch_entries_start +
4352 *pnetfid = parms->SearchHandle;
4354 cifs_buf_release(pSMB);
4361 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4362 __u16 searchHandle, __u16 search_flags,
4363 struct cifs_search_info *psrch_inf)
4365 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4366 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4367 T2_FNEXT_RSP_PARMS *parms;
4368 char *response_data;
4371 unsigned int name_len;
4372 __u16 params, byte_count;
4374 cifs_dbg(FYI, "In FindNext\n");
4376 if (psrch_inf->endOfSearch)
4379 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4384 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4386 pSMB->TotalDataCount = 0; /* no EAs */
4387 pSMB->MaxParameterCount = cpu_to_le16(8);
4388 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4389 pSMB->MaxSetupCount = 0;
4393 pSMB->Reserved2 = 0;
4394 pSMB->ParameterOffset = cpu_to_le16(
4395 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4396 pSMB->DataCount = 0;
4397 pSMB->DataOffset = 0;
4398 pSMB->SetupCount = 1;
4399 pSMB->Reserved3 = 0;
4400 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4401 pSMB->SearchHandle = searchHandle; /* always kept as le */
4403 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4404 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4405 pSMB->ResumeKey = psrch_inf->resume_key;
4406 pSMB->SearchFlags = cpu_to_le16(search_flags);
4408 name_len = psrch_inf->resume_name_len;
4410 if (name_len < PATH_MAX) {
4411 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4412 byte_count += name_len;
4413 /* 14 byte parm len above enough for 2 byte null terminator */
4414 pSMB->ResumeFileName[name_len] = 0;
4415 pSMB->ResumeFileName[name_len+1] = 0;
4418 goto FNext2_err_exit;
4420 byte_count = params + 1 /* pad */ ;
4421 pSMB->TotalParameterCount = cpu_to_le16(params);
4422 pSMB->ParameterCount = pSMB->TotalParameterCount;
4423 inc_rfc1001_len(pSMB, byte_count);
4424 pSMB->ByteCount = cpu_to_le16(byte_count);
4426 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4427 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4428 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
4431 psrch_inf->endOfSearch = true;
4432 cifs_buf_release(pSMB);
4433 rc = 0; /* search probably was closed at end of search*/
4435 cifs_dbg(FYI, "FindNext returned = %d\n", rc);
4436 } else { /* decode response */
4437 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4442 /* BB fixme add lock for file (srch_info) struct here */
4443 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4444 psrch_inf->unicode = true;
4446 psrch_inf->unicode = false;
4447 response_data = (char *) &pSMBr->hdr.Protocol +
4448 le16_to_cpu(pSMBr->t2.ParameterOffset);
4449 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4450 response_data = (char *)&pSMBr->hdr.Protocol +
4451 le16_to_cpu(pSMBr->t2.DataOffset);
4452 if (psrch_inf->smallBuf)
4453 cifs_small_buf_release(
4454 psrch_inf->ntwrk_buf_start);
4456 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4457 psrch_inf->srch_entries_start = response_data;
4458 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4459 psrch_inf->smallBuf = 0;
4460 if (parms->EndofSearch)
4461 psrch_inf->endOfSearch = true;
4463 psrch_inf->endOfSearch = false;
4464 psrch_inf->entries_in_buffer =
4465 le16_to_cpu(parms->SearchCount);
4466 psrch_inf->index_of_last_entry +=
4467 psrch_inf->entries_in_buffer;
4468 lnoff = le16_to_cpu(parms->LastNameOffset);
4469 if (CIFSMaxBufSize < lnoff) {
4470 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4471 psrch_inf->last_entry = NULL;
4474 psrch_inf->last_entry =
4475 psrch_inf->srch_entries_start + lnoff;
4477 /* cifs_dbg(FYI, "fnxt2 entries in buf %d index_of_last %d\n",
4478 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4480 /* BB fixme add unlock here */
4485 /* BB On error, should we leave previous search buf (and count and
4486 last entry fields) intact or free the previous one? */
4488 /* Note: On -EAGAIN error only caller can retry on handle based calls
4489 since file handle passed in no longer valid */
4492 cifs_buf_release(pSMB);
4497 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
4498 const __u16 searchHandle)
4501 FINDCLOSE_REQ *pSMB = NULL;
4503 cifs_dbg(FYI, "In CIFSSMBFindClose\n");
4504 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4506 /* no sense returning error if session restarted
4507 as file handle has been closed */
4513 pSMB->FileID = searchHandle;
4514 pSMB->ByteCount = 0;
4515 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4517 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
4519 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
4521 /* Since session is dead, search handle closed on server already */
4529 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
4530 const char *search_name, __u64 *inode_number,
4531 const struct nls_table *nls_codepage, int remap)
4534 TRANSACTION2_QPI_REQ *pSMB = NULL;
4535 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4536 int name_len, bytes_returned;
4537 __u16 params, byte_count;
4539 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
4543 GetInodeNumberRetry:
4544 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4549 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4551 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4552 search_name, PATH_MAX, nls_codepage,
4554 name_len++; /* trailing null */
4556 } else { /* BB improve the check for buffer overruns BB */
4557 name_len = strnlen(search_name, PATH_MAX);
4558 name_len++; /* trailing null */
4559 strncpy(pSMB->FileName, search_name, name_len);
4562 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4563 pSMB->TotalDataCount = 0;
4564 pSMB->MaxParameterCount = cpu_to_le16(2);
4565 /* BB find exact max data count below from sess structure BB */
4566 pSMB->MaxDataCount = cpu_to_le16(4000);
4567 pSMB->MaxSetupCount = 0;
4571 pSMB->Reserved2 = 0;
4572 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4573 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4574 pSMB->DataCount = 0;
4575 pSMB->DataOffset = 0;
4576 pSMB->SetupCount = 1;
4577 pSMB->Reserved3 = 0;
4578 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4579 byte_count = params + 1 /* pad */ ;
4580 pSMB->TotalParameterCount = cpu_to_le16(params);
4581 pSMB->ParameterCount = pSMB->TotalParameterCount;
4582 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4583 pSMB->Reserved4 = 0;
4584 inc_rfc1001_len(pSMB, byte_count);
4585 pSMB->ByteCount = cpu_to_le16(byte_count);
4587 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4588 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4590 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
4592 /* decode response */
4593 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4594 /* BB also check enough total bytes returned */
4595 if (rc || get_bcc(&pSMBr->hdr) < 2)
4596 /* If rc should we check for EOPNOSUPP and
4597 disable the srvino flag? or in caller? */
4598 rc = -EIO; /* bad smb */
4600 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4601 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4602 struct file_internal_info *pfinfo;
4603 /* BB Do we need a cast or hash here ? */
4605 cifs_dbg(FYI, "Illegal size ret in QryIntrnlInf\n");
4607 goto GetInodeNumOut;
4609 pfinfo = (struct file_internal_info *)
4610 (data_offset + (char *) &pSMBr->hdr.Protocol);
4611 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4615 cifs_buf_release(pSMB);
4617 goto GetInodeNumberRetry;
4621 /* parses DFS refferal V3 structure
4622 * caller is responsible for freeing target_nodes
4625 * on failure - errno
4628 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
4629 unsigned int *num_of_nodes,
4630 struct dfs_info3_param **target_nodes,
4631 const struct nls_table *nls_codepage, int remap,
4632 const char *searchName)
4637 struct dfs_referral_level_3 *ref;
4639 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4643 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4645 if (*num_of_nodes < 1) {
4646 cifs_dbg(VFS, "num_referrals: must be at least > 0, but we get num_referrals = %d\n",
4649 goto parse_DFS_referrals_exit;
4652 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
4653 if (ref->VersionNumber != cpu_to_le16(3)) {
4654 cifs_dbg(VFS, "Referrals of V%d version are not supported, should be V3\n",
4655 le16_to_cpu(ref->VersionNumber));
4657 goto parse_DFS_referrals_exit;
4660 /* get the upper boundary of the resp buffer */
4661 data_end = (char *)(&(pSMBr->PathConsumed)) +
4662 le16_to_cpu(pSMBr->t2.DataCount);
4664 cifs_dbg(FYI, "num_referrals: %d dfs flags: 0x%x ...\n",
4665 *num_of_nodes, le32_to_cpu(pSMBr->DFSFlags));
4667 *target_nodes = kcalloc(*num_of_nodes, sizeof(struct dfs_info3_param),
4669 if (*target_nodes == NULL) {
4671 goto parse_DFS_referrals_exit;
4674 /* collect necessary data from referrals */
4675 for (i = 0; i < *num_of_nodes; i++) {
4678 struct dfs_info3_param *node = (*target_nodes)+i;
4680 node->flags = le32_to_cpu(pSMBr->DFSFlags);
4682 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4686 goto parse_DFS_referrals_exit;
4688 cifsConvertToUTF16((__le16 *) tmp, searchName,
4689 PATH_MAX, nls_codepage, remap);
4690 node->path_consumed = cifs_utf16_bytes(tmp,
4691 le16_to_cpu(pSMBr->PathConsumed),
4695 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4697 node->server_type = le16_to_cpu(ref->ServerType);
4698 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4701 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4702 max_len = data_end - temp;
4703 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4704 is_unicode, nls_codepage);
4705 if (!node->path_name) {
4707 goto parse_DFS_referrals_exit;
4710 /* copy link target UNC */
4711 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4712 max_len = data_end - temp;
4713 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4714 is_unicode, nls_codepage);
4715 if (!node->node_name) {
4717 goto parse_DFS_referrals_exit;
4723 parse_DFS_referrals_exit:
4725 free_dfs_info_array(*target_nodes, *num_of_nodes);
4726 *target_nodes = NULL;
4733 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
4734 const char *search_name, struct dfs_info3_param **target_nodes,
4735 unsigned int *num_of_nodes,
4736 const struct nls_table *nls_codepage, int remap)
4738 /* TRANS2_GET_DFS_REFERRAL */
4739 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4740 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4744 __u16 params, byte_count;
4746 *target_nodes = NULL;
4748 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
4752 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4757 /* server pointer checked in called function,
4758 but should never be null here anyway */
4759 pSMB->hdr.Mid = get_next_mid(ses->server);
4760 pSMB->hdr.Tid = ses->ipc_tid;
4761 pSMB->hdr.Uid = ses->Suid;
4762 if (ses->capabilities & CAP_STATUS32)
4763 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4764 if (ses->capabilities & CAP_DFS)
4765 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4767 if (ses->capabilities & CAP_UNICODE) {
4768 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4770 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4771 search_name, PATH_MAX, nls_codepage,
4773 name_len++; /* trailing null */
4775 } else { /* BB improve the check for buffer overruns BB */
4776 name_len = strnlen(search_name, PATH_MAX);
4777 name_len++; /* trailing null */
4778 strncpy(pSMB->RequestFileName, search_name, name_len);
4781 if (ses->server && ses->server->sign)
4782 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4784 pSMB->hdr.Uid = ses->Suid;
4786 params = 2 /* level */ + name_len /*includes null */ ;
4787 pSMB->TotalDataCount = 0;
4788 pSMB->DataCount = 0;
4789 pSMB->DataOffset = 0;
4790 pSMB->MaxParameterCount = 0;
4791 /* BB find exact max SMB PDU from sess structure BB */
4792 pSMB->MaxDataCount = cpu_to_le16(4000);
4793 pSMB->MaxSetupCount = 0;
4797 pSMB->Reserved2 = 0;
4798 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4799 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4800 pSMB->SetupCount = 1;
4801 pSMB->Reserved3 = 0;
4802 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4803 byte_count = params + 3 /* pad */ ;
4804 pSMB->ParameterCount = cpu_to_le16(params);
4805 pSMB->TotalParameterCount = pSMB->ParameterCount;
4806 pSMB->MaxReferralLevel = cpu_to_le16(3);
4807 inc_rfc1001_len(pSMB, byte_count);
4808 pSMB->ByteCount = cpu_to_le16(byte_count);
4810 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4811 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4813 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
4816 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4818 /* BB Also check if enough total bytes returned? */
4819 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4820 rc = -EIO; /* bad smb */
4824 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4825 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
4827 /* parse returned result into more usable form */
4828 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
4829 target_nodes, nls_codepage, remap,
4833 cifs_buf_release(pSMB);
4841 /* Query File System Info such as free space to old servers such as Win 9x */
4843 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4844 struct kstatfs *FSData)
4846 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4847 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4848 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4849 FILE_SYSTEM_ALLOC_INFO *response_data;
4851 int bytes_returned = 0;
4852 __u16 params, byte_count;
4854 cifs_dbg(FYI, "OldQFSInfo\n");
4856 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4861 params = 2; /* level */
4862 pSMB->TotalDataCount = 0;
4863 pSMB->MaxParameterCount = cpu_to_le16(2);
4864 pSMB->MaxDataCount = cpu_to_le16(1000);
4865 pSMB->MaxSetupCount = 0;
4869 pSMB->Reserved2 = 0;
4870 byte_count = params + 1 /* pad */ ;
4871 pSMB->TotalParameterCount = cpu_to_le16(params);
4872 pSMB->ParameterCount = pSMB->TotalParameterCount;
4873 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4874 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4875 pSMB->DataCount = 0;
4876 pSMB->DataOffset = 0;
4877 pSMB->SetupCount = 1;
4878 pSMB->Reserved3 = 0;
4879 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4880 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4881 inc_rfc1001_len(pSMB, byte_count);
4882 pSMB->ByteCount = cpu_to_le16(byte_count);
4884 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4885 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4887 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4888 } else { /* decode response */
4889 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4891 if (rc || get_bcc(&pSMBr->hdr) < 18)
4892 rc = -EIO; /* bad smb */
4894 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4895 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n",
4896 get_bcc(&pSMBr->hdr), data_offset);
4898 response_data = (FILE_SYSTEM_ALLOC_INFO *)
4899 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4901 le16_to_cpu(response_data->BytesPerSector) *
4902 le32_to_cpu(response_data->
4903 SectorsPerAllocationUnit);
4905 le32_to_cpu(response_data->TotalAllocationUnits);
4906 FSData->f_bfree = FSData->f_bavail =
4907 le32_to_cpu(response_data->FreeAllocationUnits);
4908 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4909 (unsigned long long)FSData->f_blocks,
4910 (unsigned long long)FSData->f_bfree,
4914 cifs_buf_release(pSMB);
4917 goto oldQFSInfoRetry;
4923 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4924 struct kstatfs *FSData)
4926 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4927 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4928 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4929 FILE_SYSTEM_INFO *response_data;
4931 int bytes_returned = 0;
4932 __u16 params, byte_count;
4934 cifs_dbg(FYI, "In QFSInfo\n");
4936 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4941 params = 2; /* level */
4942 pSMB->TotalDataCount = 0;
4943 pSMB->MaxParameterCount = cpu_to_le16(2);
4944 pSMB->MaxDataCount = cpu_to_le16(1000);
4945 pSMB->MaxSetupCount = 0;
4949 pSMB->Reserved2 = 0;
4950 byte_count = params + 1 /* pad */ ;
4951 pSMB->TotalParameterCount = cpu_to_le16(params);
4952 pSMB->ParameterCount = pSMB->TotalParameterCount;
4953 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4954 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4955 pSMB->DataCount = 0;
4956 pSMB->DataOffset = 0;
4957 pSMB->SetupCount = 1;
4958 pSMB->Reserved3 = 0;
4959 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4960 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4961 inc_rfc1001_len(pSMB, byte_count);
4962 pSMB->ByteCount = cpu_to_le16(byte_count);
4964 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4965 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4967 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
4968 } else { /* decode response */
4969 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4971 if (rc || get_bcc(&pSMBr->hdr) < 24)
4972 rc = -EIO; /* bad smb */
4974 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4978 *) (((char *) &pSMBr->hdr.Protocol) +
4981 le32_to_cpu(response_data->BytesPerSector) *
4982 le32_to_cpu(response_data->
4983 SectorsPerAllocationUnit);
4985 le64_to_cpu(response_data->TotalAllocationUnits);
4986 FSData->f_bfree = FSData->f_bavail =
4987 le64_to_cpu(response_data->FreeAllocationUnits);
4988 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
4989 (unsigned long long)FSData->f_blocks,
4990 (unsigned long long)FSData->f_bfree,
4994 cifs_buf_release(pSMB);
5003 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
5005 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5006 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5007 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5008 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5010 int bytes_returned = 0;
5011 __u16 params, byte_count;
5013 cifs_dbg(FYI, "In QFSAttributeInfo\n");
5015 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5020 params = 2; /* level */
5021 pSMB->TotalDataCount = 0;
5022 pSMB->MaxParameterCount = cpu_to_le16(2);
5023 /* BB find exact max SMB PDU from sess structure BB */
5024 pSMB->MaxDataCount = cpu_to_le16(1000);
5025 pSMB->MaxSetupCount = 0;
5029 pSMB->Reserved2 = 0;
5030 byte_count = params + 1 /* pad */ ;
5031 pSMB->TotalParameterCount = cpu_to_le16(params);
5032 pSMB->ParameterCount = pSMB->TotalParameterCount;
5033 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5034 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5035 pSMB->DataCount = 0;
5036 pSMB->DataOffset = 0;
5037 pSMB->SetupCount = 1;
5038 pSMB->Reserved3 = 0;
5039 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5040 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
5041 inc_rfc1001_len(pSMB, byte_count);
5042 pSMB->ByteCount = cpu_to_le16(byte_count);
5044 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5045 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5047 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
5048 } else { /* decode response */
5049 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5051 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5052 /* BB also check if enough bytes returned */
5053 rc = -EIO; /* bad smb */
5055 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5057 (FILE_SYSTEM_ATTRIBUTE_INFO
5058 *) (((char *) &pSMBr->hdr.Protocol) +
5060 memcpy(&tcon->fsAttrInfo, response_data,
5061 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
5064 cifs_buf_release(pSMB);
5067 goto QFSAttributeRetry;
5073 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
5075 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5076 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5077 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5078 FILE_SYSTEM_DEVICE_INFO *response_data;
5080 int bytes_returned = 0;
5081 __u16 params, byte_count;
5083 cifs_dbg(FYI, "In QFSDeviceInfo\n");
5085 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5090 params = 2; /* level */
5091 pSMB->TotalDataCount = 0;
5092 pSMB->MaxParameterCount = cpu_to_le16(2);
5093 /* BB find exact max SMB PDU from sess structure BB */
5094 pSMB->MaxDataCount = cpu_to_le16(1000);
5095 pSMB->MaxSetupCount = 0;
5099 pSMB->Reserved2 = 0;
5100 byte_count = params + 1 /* pad */ ;
5101 pSMB->TotalParameterCount = cpu_to_le16(params);
5102 pSMB->ParameterCount = pSMB->TotalParameterCount;
5103 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5104 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5106 pSMB->DataCount = 0;
5107 pSMB->DataOffset = 0;
5108 pSMB->SetupCount = 1;
5109 pSMB->Reserved3 = 0;
5110 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5111 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
5112 inc_rfc1001_len(pSMB, byte_count);
5113 pSMB->ByteCount = cpu_to_le16(byte_count);
5115 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5116 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5118 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
5119 } else { /* decode response */
5120 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5122 if (rc || get_bcc(&pSMBr->hdr) <
5123 sizeof(FILE_SYSTEM_DEVICE_INFO))
5124 rc = -EIO; /* bad smb */
5126 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5128 (FILE_SYSTEM_DEVICE_INFO *)
5129 (((char *) &pSMBr->hdr.Protocol) +
5131 memcpy(&tcon->fsDevInfo, response_data,
5132 sizeof(FILE_SYSTEM_DEVICE_INFO));
5135 cifs_buf_release(pSMB);
5138 goto QFSDeviceRetry;
5144 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
5146 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5147 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5148 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5149 FILE_SYSTEM_UNIX_INFO *response_data;
5151 int bytes_returned = 0;
5152 __u16 params, byte_count;
5154 cifs_dbg(FYI, "In QFSUnixInfo\n");
5156 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5157 (void **) &pSMB, (void **) &pSMBr);
5161 params = 2; /* level */
5162 pSMB->TotalDataCount = 0;
5163 pSMB->DataCount = 0;
5164 pSMB->DataOffset = 0;
5165 pSMB->MaxParameterCount = cpu_to_le16(2);
5166 /* BB find exact max SMB PDU from sess structure BB */
5167 pSMB->MaxDataCount = cpu_to_le16(100);
5168 pSMB->MaxSetupCount = 0;
5172 pSMB->Reserved2 = 0;
5173 byte_count = params + 1 /* pad */ ;
5174 pSMB->ParameterCount = cpu_to_le16(params);
5175 pSMB->TotalParameterCount = pSMB->ParameterCount;
5176 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5177 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5178 pSMB->SetupCount = 1;
5179 pSMB->Reserved3 = 0;
5180 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5181 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
5182 inc_rfc1001_len(pSMB, byte_count);
5183 pSMB->ByteCount = cpu_to_le16(byte_count);
5185 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5186 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5188 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
5189 } else { /* decode response */
5190 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5192 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5193 rc = -EIO; /* bad smb */
5195 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5197 (FILE_SYSTEM_UNIX_INFO
5198 *) (((char *) &pSMBr->hdr.Protocol) +
5200 memcpy(&tcon->fsUnixInfo, response_data,
5201 sizeof(FILE_SYSTEM_UNIX_INFO));
5204 cifs_buf_release(pSMB);
5214 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
5216 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5217 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5218 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5220 int bytes_returned = 0;
5221 __u16 params, param_offset, offset, byte_count;
5223 cifs_dbg(FYI, "In SETFSUnixInfo\n");
5225 /* BB switch to small buf init to save memory */
5226 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5227 (void **) &pSMB, (void **) &pSMBr);
5231 params = 4; /* 2 bytes zero followed by info level. */
5232 pSMB->MaxSetupCount = 0;
5236 pSMB->Reserved2 = 0;
5237 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5239 offset = param_offset + params;
5241 pSMB->MaxParameterCount = cpu_to_le16(4);
5242 /* BB find exact max SMB PDU from sess structure BB */
5243 pSMB->MaxDataCount = cpu_to_le16(100);
5244 pSMB->SetupCount = 1;
5245 pSMB->Reserved3 = 0;
5246 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5247 byte_count = 1 /* pad */ + params + 12;
5249 pSMB->DataCount = cpu_to_le16(12);
5250 pSMB->ParameterCount = cpu_to_le16(params);
5251 pSMB->TotalDataCount = pSMB->DataCount;
5252 pSMB->TotalParameterCount = pSMB->ParameterCount;
5253 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5254 pSMB->DataOffset = cpu_to_le16(offset);
5258 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5261 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5262 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5263 pSMB->ClientUnixCap = cpu_to_le64(cap);
5265 inc_rfc1001_len(pSMB, byte_count);
5266 pSMB->ByteCount = cpu_to_le16(byte_count);
5268 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5269 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5271 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
5272 } else { /* decode response */
5273 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5275 rc = -EIO; /* bad smb */
5277 cifs_buf_release(pSMB);
5280 goto SETFSUnixRetry;
5288 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
5289 struct kstatfs *FSData)
5291 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5292 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5293 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5294 FILE_SYSTEM_POSIX_INFO *response_data;
5296 int bytes_returned = 0;
5297 __u16 params, byte_count;
5299 cifs_dbg(FYI, "In QFSPosixInfo\n");
5301 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5306 params = 2; /* level */
5307 pSMB->TotalDataCount = 0;
5308 pSMB->DataCount = 0;
5309 pSMB->DataOffset = 0;
5310 pSMB->MaxParameterCount = cpu_to_le16(2);
5311 /* BB find exact max SMB PDU from sess structure BB */
5312 pSMB->MaxDataCount = cpu_to_le16(100);
5313 pSMB->MaxSetupCount = 0;
5317 pSMB->Reserved2 = 0;
5318 byte_count = params + 1 /* pad */ ;
5319 pSMB->ParameterCount = cpu_to_le16(params);
5320 pSMB->TotalParameterCount = pSMB->ParameterCount;
5321 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5322 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5323 pSMB->SetupCount = 1;
5324 pSMB->Reserved3 = 0;
5325 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5326 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
5327 inc_rfc1001_len(pSMB, byte_count);
5328 pSMB->ByteCount = cpu_to_le16(byte_count);
5330 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5331 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5333 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
5334 } else { /* decode response */
5335 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5337 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5338 rc = -EIO; /* bad smb */
5340 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5342 (FILE_SYSTEM_POSIX_INFO
5343 *) (((char *) &pSMBr->hdr.Protocol) +
5346 le32_to_cpu(response_data->BlockSize);
5348 le64_to_cpu(response_data->TotalBlocks);
5350 le64_to_cpu(response_data->BlocksAvail);
5351 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
5352 FSData->f_bavail = FSData->f_bfree;
5355 le64_to_cpu(response_data->UserBlocksAvail);
5357 if (response_data->TotalFileNodes != cpu_to_le64(-1))
5359 le64_to_cpu(response_data->TotalFileNodes);
5360 if (response_data->FreeFileNodes != cpu_to_le64(-1))
5362 le64_to_cpu(response_data->FreeFileNodes);
5365 cifs_buf_release(pSMB);
5375 * We can not use write of zero bytes trick to set file size due to need for
5376 * large file support. Also note that this SetPathInfo is preferred to
5377 * SetFileInfo based method in next routine which is only needed to work around
5378 * a sharing violation bugin Samba which this routine can run into.
5381 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
5382 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
5383 bool set_allocation)
5385 struct smb_com_transaction2_spi_req *pSMB = NULL;
5386 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5387 struct file_end_of_file_info *parm_data;
5390 int bytes_returned = 0;
5391 int remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
5393 __u16 params, byte_count, data_count, param_offset, offset;
5395 cifs_dbg(FYI, "In SetEOF\n");
5397 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5402 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5404 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5405 PATH_MAX, cifs_sb->local_nls, remap);
5406 name_len++; /* trailing null */
5408 } else { /* BB improve the check for buffer overruns BB */
5409 name_len = strnlen(file_name, PATH_MAX);
5410 name_len++; /* trailing null */
5411 strncpy(pSMB->FileName, file_name, name_len);
5413 params = 6 + name_len;
5414 data_count = sizeof(struct file_end_of_file_info);
5415 pSMB->MaxParameterCount = cpu_to_le16(2);
5416 pSMB->MaxDataCount = cpu_to_le16(4100);
5417 pSMB->MaxSetupCount = 0;
5421 pSMB->Reserved2 = 0;
5422 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5423 InformationLevel) - 4;
5424 offset = param_offset + params;
5425 if (set_allocation) {
5426 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5427 pSMB->InformationLevel =
5428 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5430 pSMB->InformationLevel =
5431 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5432 } else /* Set File Size */ {
5433 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5434 pSMB->InformationLevel =
5435 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5437 pSMB->InformationLevel =
5438 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5442 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5444 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5445 pSMB->DataOffset = cpu_to_le16(offset);
5446 pSMB->SetupCount = 1;
5447 pSMB->Reserved3 = 0;
5448 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5449 byte_count = 3 /* pad */ + params + data_count;
5450 pSMB->DataCount = cpu_to_le16(data_count);
5451 pSMB->TotalDataCount = pSMB->DataCount;
5452 pSMB->ParameterCount = cpu_to_le16(params);
5453 pSMB->TotalParameterCount = pSMB->ParameterCount;
5454 pSMB->Reserved4 = 0;
5455 inc_rfc1001_len(pSMB, byte_count);
5456 parm_data->FileSize = cpu_to_le64(size);
5457 pSMB->ByteCount = cpu_to_le16(byte_count);
5458 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5459 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5461 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
5463 cifs_buf_release(pSMB);
5472 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5473 struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
5475 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5476 struct file_end_of_file_info *parm_data;
5478 __u16 params, param_offset, offset, byte_count, count;
5480 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5482 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5487 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5488 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
5491 pSMB->MaxSetupCount = 0;
5495 pSMB->Reserved2 = 0;
5496 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5497 offset = param_offset + params;
5499 count = sizeof(struct file_end_of_file_info);
5500 pSMB->MaxParameterCount = cpu_to_le16(2);
5501 /* BB find exact max SMB PDU from sess structure BB */
5502 pSMB->MaxDataCount = cpu_to_le16(1000);
5503 pSMB->SetupCount = 1;
5504 pSMB->Reserved3 = 0;
5505 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5506 byte_count = 3 /* pad */ + params + count;
5507 pSMB->DataCount = cpu_to_le16(count);
5508 pSMB->ParameterCount = cpu_to_le16(params);
5509 pSMB->TotalDataCount = pSMB->DataCount;
5510 pSMB->TotalParameterCount = pSMB->ParameterCount;
5511 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5513 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5515 pSMB->DataOffset = cpu_to_le16(offset);
5516 parm_data->FileSize = cpu_to_le64(size);
5517 pSMB->Fid = cfile->fid.netfid;
5518 if (set_allocation) {
5519 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5520 pSMB->InformationLevel =
5521 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5523 pSMB->InformationLevel =
5524 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5525 } else /* Set File Size */ {
5526 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5527 pSMB->InformationLevel =
5528 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5530 pSMB->InformationLevel =
5531 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5533 pSMB->Reserved4 = 0;
5534 inc_rfc1001_len(pSMB, byte_count);
5535 pSMB->ByteCount = cpu_to_le16(byte_count);
5536 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5538 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5542 /* Note: On -EAGAIN error only caller can retry on handle based calls
5543 since file handle passed in no longer valid */
5548 /* Some legacy servers such as NT4 require that the file times be set on
5549 an open handle, rather than by pathname - this is awkward due to
5550 potential access conflicts on the open, but it is unavoidable for these
5551 old servers since the only other choice is to go from 100 nanosecond DCE
5552 time and resort to the original setpathinfo level which takes the ancient
5553 DOS time format with 2 second granularity */
5555 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5556 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5558 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5561 __u16 params, param_offset, offset, byte_count, count;
5563 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
5564 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5569 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5570 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5573 pSMB->MaxSetupCount = 0;
5577 pSMB->Reserved2 = 0;
5578 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5579 offset = param_offset + params;
5581 data_offset = (char *)pSMB +
5582 offsetof(struct smb_hdr, Protocol) + offset;
5584 count = sizeof(FILE_BASIC_INFO);
5585 pSMB->MaxParameterCount = cpu_to_le16(2);
5586 /* BB find max SMB PDU from sess */
5587 pSMB->MaxDataCount = cpu_to_le16(1000);
5588 pSMB->SetupCount = 1;
5589 pSMB->Reserved3 = 0;
5590 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5591 byte_count = 3 /* pad */ + params + count;
5592 pSMB->DataCount = cpu_to_le16(count);
5593 pSMB->ParameterCount = cpu_to_le16(params);
5594 pSMB->TotalDataCount = pSMB->DataCount;
5595 pSMB->TotalParameterCount = pSMB->ParameterCount;
5596 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5597 pSMB->DataOffset = cpu_to_le16(offset);
5599 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5600 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5602 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5603 pSMB->Reserved4 = 0;
5604 inc_rfc1001_len(pSMB, byte_count);
5605 pSMB->ByteCount = cpu_to_le16(byte_count);
5606 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5607 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5609 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5612 /* Note: On -EAGAIN error only caller can retry on handle based calls
5613 since file handle passed in no longer valid */
5619 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
5620 bool delete_file, __u16 fid, __u32 pid_of_opener)
5622 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5625 __u16 params, param_offset, offset, byte_count, count;
5627 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
5628 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5633 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5634 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5637 pSMB->MaxSetupCount = 0;
5641 pSMB->Reserved2 = 0;
5642 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5643 offset = param_offset + params;
5645 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5648 pSMB->MaxParameterCount = cpu_to_le16(2);
5649 /* BB find max SMB PDU from sess */
5650 pSMB->MaxDataCount = cpu_to_le16(1000);
5651 pSMB->SetupCount = 1;
5652 pSMB->Reserved3 = 0;
5653 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5654 byte_count = 3 /* pad */ + params + count;
5655 pSMB->DataCount = cpu_to_le16(count);
5656 pSMB->ParameterCount = cpu_to_le16(params);
5657 pSMB->TotalDataCount = pSMB->DataCount;
5658 pSMB->TotalParameterCount = pSMB->ParameterCount;
5659 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5660 pSMB->DataOffset = cpu_to_le16(offset);
5662 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5663 pSMB->Reserved4 = 0;
5664 inc_rfc1001_len(pSMB, byte_count);
5665 pSMB->ByteCount = cpu_to_le16(byte_count);
5666 *data_offset = delete_file ? 1 : 0;
5667 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5669 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
5675 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5676 const char *fileName, const FILE_BASIC_INFO *data,
5677 const struct nls_table *nls_codepage, int remap)
5679 TRANSACTION2_SPI_REQ *pSMB = NULL;
5680 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5683 int bytes_returned = 0;
5685 __u16 params, param_offset, offset, byte_count, count;
5687 cifs_dbg(FYI, "In SetTimes\n");
5690 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5695 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5697 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5698 PATH_MAX, nls_codepage, remap);
5699 name_len++; /* trailing null */
5701 } else { /* BB improve the check for buffer overruns BB */
5702 name_len = strnlen(fileName, PATH_MAX);
5703 name_len++; /* trailing null */
5704 strncpy(pSMB->FileName, fileName, name_len);
5707 params = 6 + name_len;
5708 count = sizeof(FILE_BASIC_INFO);
5709 pSMB->MaxParameterCount = cpu_to_le16(2);
5710 /* BB find max SMB PDU from sess structure BB */
5711 pSMB->MaxDataCount = cpu_to_le16(1000);
5712 pSMB->MaxSetupCount = 0;
5716 pSMB->Reserved2 = 0;
5717 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5718 InformationLevel) - 4;
5719 offset = param_offset + params;
5720 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5721 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5722 pSMB->DataOffset = cpu_to_le16(offset);
5723 pSMB->SetupCount = 1;
5724 pSMB->Reserved3 = 0;
5725 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5726 byte_count = 3 /* pad */ + params + count;
5728 pSMB->DataCount = cpu_to_le16(count);
5729 pSMB->ParameterCount = cpu_to_le16(params);
5730 pSMB->TotalDataCount = pSMB->DataCount;
5731 pSMB->TotalParameterCount = pSMB->ParameterCount;
5732 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5733 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5735 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5736 pSMB->Reserved4 = 0;
5737 inc_rfc1001_len(pSMB, byte_count);
5738 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5739 pSMB->ByteCount = cpu_to_le16(byte_count);
5740 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5741 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5743 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
5745 cifs_buf_release(pSMB);
5753 /* Can not be used to set time stamps yet (due to old DOS time format) */
5754 /* Can be used to set attributes */
5755 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5756 handling it anyway and NT4 was what we thought it would be needed for
5757 Do not delete it until we prove whether needed for Win9x though */
5759 CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon, char *fileName,
5760 __u16 dos_attrs, const struct nls_table *nls_codepage)
5762 SETATTR_REQ *pSMB = NULL;
5763 SETATTR_RSP *pSMBr = NULL;
5768 cifs_dbg(FYI, "In SetAttrLegacy\n");
5771 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5776 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5778 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5779 PATH_MAX, nls_codepage);
5780 name_len++; /* trailing null */
5782 } else { /* BB improve the check for buffer overruns BB */
5783 name_len = strnlen(fileName, PATH_MAX);
5784 name_len++; /* trailing null */
5785 strncpy(pSMB->fileName, fileName, name_len);
5787 pSMB->attr = cpu_to_le16(dos_attrs);
5788 pSMB->BufferFormat = 0x04;
5789 inc_rfc1001_len(pSMB, name_len + 1);
5790 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5791 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5792 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5794 cifs_dbg(FYI, "Error in LegacySetAttr = %d\n", rc);
5796 cifs_buf_release(pSMB);
5799 goto SetAttrLgcyRetry;
5803 #endif /* temporarily unneeded SetAttr legacy function */
5806 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5807 const struct cifs_unix_set_info_args *args)
5809 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
5810 u64 mode = args->mode;
5812 if (uid_valid(args->uid))
5813 uid = from_kuid(&init_user_ns, args->uid);
5814 if (gid_valid(args->gid))
5815 gid = from_kgid(&init_user_ns, args->gid);
5818 * Samba server ignores set of file size to zero due to bugs in some
5819 * older clients, but we should be precise - we use SetFileSize to
5820 * set file size and do not want to truncate file size to zero
5821 * accidentally as happened on one Samba server beta by putting
5822 * zero instead of -1 here
5824 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5825 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5826 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5827 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5828 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5829 data_offset->Uid = cpu_to_le64(uid);
5830 data_offset->Gid = cpu_to_le64(gid);
5831 /* better to leave device as zero when it is */
5832 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5833 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5834 data_offset->Permissions = cpu_to_le64(mode);
5837 data_offset->Type = cpu_to_le32(UNIX_FILE);
5838 else if (S_ISDIR(mode))
5839 data_offset->Type = cpu_to_le32(UNIX_DIR);
5840 else if (S_ISLNK(mode))
5841 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5842 else if (S_ISCHR(mode))
5843 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5844 else if (S_ISBLK(mode))
5845 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5846 else if (S_ISFIFO(mode))
5847 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5848 else if (S_ISSOCK(mode))
5849 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5853 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5854 const struct cifs_unix_set_info_args *args,
5855 u16 fid, u32 pid_of_opener)
5857 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5860 u16 params, param_offset, offset, byte_count, count;
5862 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
5863 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5868 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5869 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5872 pSMB->MaxSetupCount = 0;
5876 pSMB->Reserved2 = 0;
5877 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5878 offset = param_offset + params;
5880 data_offset = (char *)pSMB +
5881 offsetof(struct smb_hdr, Protocol) + offset;
5883 count = sizeof(FILE_UNIX_BASIC_INFO);
5885 pSMB->MaxParameterCount = cpu_to_le16(2);
5886 /* BB find max SMB PDU from sess */
5887 pSMB->MaxDataCount = cpu_to_le16(1000);
5888 pSMB->SetupCount = 1;
5889 pSMB->Reserved3 = 0;
5890 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5891 byte_count = 3 /* pad */ + params + count;
5892 pSMB->DataCount = cpu_to_le16(count);
5893 pSMB->ParameterCount = cpu_to_le16(params);
5894 pSMB->TotalDataCount = pSMB->DataCount;
5895 pSMB->TotalParameterCount = pSMB->ParameterCount;
5896 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5897 pSMB->DataOffset = cpu_to_le16(offset);
5899 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5900 pSMB->Reserved4 = 0;
5901 inc_rfc1001_len(pSMB, byte_count);
5902 pSMB->ByteCount = cpu_to_le16(byte_count);
5904 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
5906 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5908 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5911 /* Note: On -EAGAIN error only caller can retry on handle based calls
5912 since file handle passed in no longer valid */
5918 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5919 const char *file_name,
5920 const struct cifs_unix_set_info_args *args,
5921 const struct nls_table *nls_codepage, int remap)
5923 TRANSACTION2_SPI_REQ *pSMB = NULL;
5924 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5927 int bytes_returned = 0;
5928 FILE_UNIX_BASIC_INFO *data_offset;
5929 __u16 params, param_offset, offset, count, byte_count;
5931 cifs_dbg(FYI, "In SetUID/GID/Mode\n");
5933 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5938 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5940 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5941 PATH_MAX, nls_codepage, remap);
5942 name_len++; /* trailing null */
5944 } else { /* BB improve the check for buffer overruns BB */
5945 name_len = strnlen(file_name, PATH_MAX);
5946 name_len++; /* trailing null */
5947 strncpy(pSMB->FileName, file_name, name_len);
5950 params = 6 + name_len;
5951 count = sizeof(FILE_UNIX_BASIC_INFO);
5952 pSMB->MaxParameterCount = cpu_to_le16(2);
5953 /* BB find max SMB PDU from sess structure BB */
5954 pSMB->MaxDataCount = cpu_to_le16(1000);
5955 pSMB->MaxSetupCount = 0;
5959 pSMB->Reserved2 = 0;
5960 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5961 InformationLevel) - 4;
5962 offset = param_offset + params;
5964 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
5966 memset(data_offset, 0, count);
5967 pSMB->DataOffset = cpu_to_le16(offset);
5968 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5969 pSMB->SetupCount = 1;
5970 pSMB->Reserved3 = 0;
5971 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5972 byte_count = 3 /* pad */ + params + count;
5973 pSMB->ParameterCount = cpu_to_le16(params);
5974 pSMB->DataCount = cpu_to_le16(count);
5975 pSMB->TotalParameterCount = pSMB->ParameterCount;
5976 pSMB->TotalDataCount = pSMB->DataCount;
5977 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5978 pSMB->Reserved4 = 0;
5979 inc_rfc1001_len(pSMB, byte_count);
5981 cifs_fill_unix_set_info(data_offset, args);
5983 pSMB->ByteCount = cpu_to_le16(byte_count);
5984 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5985 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5987 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
5989 cifs_buf_release(pSMB);
5995 #ifdef CONFIG_CIFS_XATTR
5997 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
5998 * function used by listxattr and getxattr type calls. When ea_name is set,
5999 * it looks for that attribute name and stuffs that value into the EAData
6000 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6001 * buffer. In both cases, the return value is either the length of the
6002 * resulting data or a negative error code. If EAData is a NULL pointer then
6003 * the data isn't copied to it, but the length is returned.
6006 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
6007 const unsigned char *searchName, const unsigned char *ea_name,
6008 char *EAData, size_t buf_size,
6009 const struct nls_table *nls_codepage, int remap)
6011 /* BB assumes one setup word */
6012 TRANSACTION2_QPI_REQ *pSMB = NULL;
6013 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6017 struct fealist *ea_response_data;
6018 struct fea *temp_fea;
6021 __u16 params, byte_count, data_offset;
6022 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
6024 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
6026 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6031 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6033 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6034 PATH_MAX, nls_codepage, remap);
6035 list_len++; /* trailing null */
6037 } else { /* BB improve the check for buffer overruns BB */
6038 list_len = strnlen(searchName, PATH_MAX);
6039 list_len++; /* trailing null */
6040 strncpy(pSMB->FileName, searchName, list_len);
6043 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
6044 pSMB->TotalDataCount = 0;
6045 pSMB->MaxParameterCount = cpu_to_le16(2);
6046 /* BB find exact max SMB PDU from sess structure BB */
6047 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
6048 pSMB->MaxSetupCount = 0;
6052 pSMB->Reserved2 = 0;
6053 pSMB->ParameterOffset = cpu_to_le16(offsetof(
6054 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
6055 pSMB->DataCount = 0;
6056 pSMB->DataOffset = 0;
6057 pSMB->SetupCount = 1;
6058 pSMB->Reserved3 = 0;
6059 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6060 byte_count = params + 1 /* pad */ ;
6061 pSMB->TotalParameterCount = cpu_to_le16(params);
6062 pSMB->ParameterCount = pSMB->TotalParameterCount;
6063 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6064 pSMB->Reserved4 = 0;
6065 inc_rfc1001_len(pSMB, byte_count);
6066 pSMB->ByteCount = cpu_to_le16(byte_count);
6068 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6069 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6071 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
6076 /* BB also check enough total bytes returned */
6077 /* BB we need to improve the validity checking
6078 of these trans2 responses */
6080 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6081 if (rc || get_bcc(&pSMBr->hdr) < 4) {
6082 rc = -EIO; /* bad smb */
6086 /* check that length of list is not more than bcc */
6087 /* check that each entry does not go beyond length
6089 /* check that each element of each entry does not
6090 go beyond end of list */
6091 /* validate_trans2_offsets() */
6092 /* BB check if start of smb + data_offset > &bcc+ bcc */
6094 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6095 ea_response_data = (struct fealist *)
6096 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6098 list_len = le32_to_cpu(ea_response_data->list_len);
6099 cifs_dbg(FYI, "ea length %d\n", list_len);
6100 if (list_len <= 8) {
6101 cifs_dbg(FYI, "empty EA list returned from server\n");
6105 /* make sure list_len doesn't go past end of SMB */
6106 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
6107 if ((char *)ea_response_data + list_len > end_of_smb) {
6108 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
6113 /* account for ea list len */
6115 temp_fea = ea_response_data->list;
6116 temp_ptr = (char *)temp_fea;
6117 while (list_len > 0) {
6118 unsigned int name_len;
6123 /* make sure we can read name_len and value_len */
6125 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6130 name_len = temp_fea->name_len;
6131 value_len = le16_to_cpu(temp_fea->value_len);
6132 list_len -= name_len + 1 + value_len;
6134 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6140 if (ea_name_len == name_len &&
6141 memcmp(ea_name, temp_ptr, name_len) == 0) {
6142 temp_ptr += name_len + 1;
6146 if ((size_t)value_len > buf_size) {
6150 memcpy(EAData, temp_ptr, value_len);
6154 /* account for prefix user. and trailing null */
6155 rc += (5 + 1 + name_len);
6156 if (rc < (int) buf_size) {
6157 memcpy(EAData, "user.", 5);
6159 memcpy(EAData, temp_ptr, name_len);
6161 /* null terminate name */
6164 } else if (buf_size == 0) {
6165 /* skip copy - calc size only */
6167 /* stop before overrun buffer */
6172 temp_ptr += name_len + 1 + value_len;
6173 temp_fea = (struct fea *)temp_ptr;
6176 /* didn't find the named attribute */
6181 cifs_buf_release(pSMB);
6189 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
6190 const char *fileName, const char *ea_name, const void *ea_value,
6191 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6194 struct smb_com_transaction2_spi_req *pSMB = NULL;
6195 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6196 struct fealist *parm_data;
6199 int bytes_returned = 0;
6200 __u16 params, param_offset, byte_count, offset, count;
6202 cifs_dbg(FYI, "In SetEA\n");
6204 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6209 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6211 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6212 PATH_MAX, nls_codepage, remap);
6213 name_len++; /* trailing null */
6215 } else { /* BB improve the check for buffer overruns BB */
6216 name_len = strnlen(fileName, PATH_MAX);
6217 name_len++; /* trailing null */
6218 strncpy(pSMB->FileName, fileName, name_len);
6221 params = 6 + name_len;
6223 /* done calculating parms using name_len of file name,
6224 now use name_len to calculate length of ea name
6225 we are going to create in the inode xattrs */
6226 if (ea_name == NULL)
6229 name_len = strnlen(ea_name, 255);
6231 count = sizeof(*parm_data) + ea_value_len + name_len;
6232 pSMB->MaxParameterCount = cpu_to_le16(2);
6233 /* BB find max SMB PDU from sess */
6234 pSMB->MaxDataCount = cpu_to_le16(1000);
6235 pSMB->MaxSetupCount = 0;
6239 pSMB->Reserved2 = 0;
6240 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6241 InformationLevel) - 4;
6242 offset = param_offset + params;
6243 pSMB->InformationLevel =
6244 cpu_to_le16(SMB_SET_FILE_EA);
6247 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6249 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6250 pSMB->DataOffset = cpu_to_le16(offset);
6251 pSMB->SetupCount = 1;
6252 pSMB->Reserved3 = 0;
6253 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6254 byte_count = 3 /* pad */ + params + count;
6255 pSMB->DataCount = cpu_to_le16(count);
6256 parm_data->list_len = cpu_to_le32(count);
6257 parm_data->list[0].EA_flags = 0;
6258 /* we checked above that name len is less than 255 */
6259 parm_data->list[0].name_len = (__u8)name_len;
6260 /* EA names are always ASCII */
6262 strncpy(parm_data->list[0].name, ea_name, name_len);
6263 parm_data->list[0].name[name_len] = 0;
6264 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6265 /* caller ensures that ea_value_len is less than 64K but
6266 we need to ensure that it fits within the smb */
6268 /*BB add length check to see if it would fit in
6269 negotiated SMB buffer size BB */
6270 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6272 memcpy(parm_data->list[0].name+name_len+1,
6273 ea_value, ea_value_len);
6275 pSMB->TotalDataCount = pSMB->DataCount;
6276 pSMB->ParameterCount = cpu_to_le16(params);
6277 pSMB->TotalParameterCount = pSMB->ParameterCount;
6278 pSMB->Reserved4 = 0;
6279 inc_rfc1001_len(pSMB, byte_count);
6280 pSMB->ByteCount = cpu_to_le16(byte_count);
6281 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6282 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6284 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
6286 cifs_buf_release(pSMB);
6295 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6297 * Years ago the kernel added a "dnotify" function for Samba server,
6298 * to allow network clients (such as Windows) to display updated
6299 * lists of files in directory listings automatically when
6300 * files are added by one user when another user has the
6301 * same directory open on their desktop. The Linux cifs kernel
6302 * client hooked into the kernel side of this interface for
6303 * the same reason, but ironically when the VFS moved from
6304 * "dnotify" to "inotify" it became harder to plug in Linux
6305 * network file system clients (the most obvious use case
6306 * for notify interfaces is when multiple users can update
6307 * the contents of the same directory - exactly what network
6308 * file systems can do) although the server (Samba) could
6309 * still use it. For the short term we leave the worker
6310 * function ifdeffed out (below) until inotify is fixed
6311 * in the VFS to make it easier to plug in network file
6312 * system clients. If inotify turns out to be permanently
6313 * incompatible for network fs clients, we could instead simply
6314 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6316 int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
6317 const int notify_subdirs, const __u16 netfid,
6318 __u32 filter, struct file *pfile, int multishot,
6319 const struct nls_table *nls_codepage)
6322 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6323 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6324 struct dir_notify_req *dnotify_req;
6327 cifs_dbg(FYI, "In CIFSSMBNotify for file handle %d\n", (int)netfid);
6328 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6333 pSMB->TotalParameterCount = 0 ;
6334 pSMB->TotalDataCount = 0;
6335 pSMB->MaxParameterCount = cpu_to_le32(2);
6336 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
6337 pSMB->MaxSetupCount = 4;
6339 pSMB->ParameterOffset = 0;
6340 pSMB->DataCount = 0;
6341 pSMB->DataOffset = 0;
6342 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6343 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6344 pSMB->ParameterCount = pSMB->TotalParameterCount;
6346 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6347 pSMB->Reserved2 = 0;
6348 pSMB->CompletionFilter = cpu_to_le32(filter);
6349 pSMB->Fid = netfid; /* file handle always le */
6350 pSMB->ByteCount = 0;
6352 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6353 (struct smb_hdr *)pSMBr, &bytes_returned,
6356 cifs_dbg(FYI, "Error in Notify = %d\n", rc);
6358 /* Add file to outstanding requests */
6359 /* BB change to kmem cache alloc */
6360 dnotify_req = kmalloc(
6361 sizeof(struct dir_notify_req),
6364 dnotify_req->Pid = pSMB->hdr.Pid;
6365 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6366 dnotify_req->Mid = pSMB->hdr.Mid;
6367 dnotify_req->Tid = pSMB->hdr.Tid;
6368 dnotify_req->Uid = pSMB->hdr.Uid;
6369 dnotify_req->netfid = netfid;
6370 dnotify_req->pfile = pfile;
6371 dnotify_req->filter = filter;
6372 dnotify_req->multishot = multishot;
6373 spin_lock(&GlobalMid_Lock);
6374 list_add_tail(&dnotify_req->lhead,
6375 &GlobalDnotifyReqList);
6376 spin_unlock(&GlobalMid_Lock);
6380 cifs_buf_release(pSMB);
6383 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */