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 */
89 /* Forward declarations */
90 static void cifs_readv_complete(struct work_struct *work);
92 /* Mark as invalid, all open files on tree connections since they
93 were closed when session to server was lost */
94 static void mark_open_files_invalid(struct cifs_tcon *pTcon)
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, &pTcon->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);
108 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
112 /* reconnect the socket, tcon, and smb session if needed */
114 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
117 struct cifs_ses *ses;
118 struct TCP_Server_Info *server;
119 struct nls_table *nls_codepage;
122 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
123 * tcp and smb session status done differently for those three - in the
130 server = ses->server;
133 * only tree disconnect, open, and write, (and ulogoff which does not
134 * have tcon) are allowed as we start force umount
136 if (tcon->tidStatus == CifsExiting) {
137 if (smb_command != SMB_COM_WRITE_ANDX &&
138 smb_command != SMB_COM_OPEN_ANDX &&
139 smb_command != SMB_COM_TREE_DISCONNECT) {
140 cFYI(1, "can not send cmd %d while umounting",
147 * Give demultiplex thread up to 10 seconds to reconnect, should be
148 * greater than cifs socket timeout which is 7 seconds
150 while (server->tcpStatus == CifsNeedReconnect) {
151 wait_event_interruptible_timeout(server->response_q,
152 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
154 /* are we still trying to reconnect? */
155 if (server->tcpStatus != CifsNeedReconnect)
159 * on "soft" mounts we wait once. Hard mounts keep
160 * retrying until process is killed or server comes
164 cFYI(1, "gave up waiting on reconnect in smb_init");
169 if (!ses->need_reconnect && !tcon->need_reconnect)
172 nls_codepage = load_nls_default();
175 * need to prevent multiple threads trying to simultaneously
176 * reconnect the same SMB session
178 mutex_lock(&ses->session_mutex);
179 rc = cifs_negotiate_protocol(0, ses);
180 if (rc == 0 && ses->need_reconnect)
181 rc = cifs_setup_session(0, ses, nls_codepage);
183 /* do we need to reconnect tcon? */
184 if (rc || !tcon->need_reconnect) {
185 mutex_unlock(&ses->session_mutex);
189 mark_open_files_invalid(tcon);
190 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
191 mutex_unlock(&ses->session_mutex);
192 cFYI(1, "reconnect tcon rc = %d", rc);
198 * FIXME: check if wsize needs updated due to negotiated smb buffer
201 atomic_inc(&tconInfoReconnectCount);
203 /* tell server Unix caps we support */
204 if (ses->capabilities & CAP_UNIX)
205 reset_cifs_unix_caps(0, tcon, NULL, NULL);
208 * Removed call to reopen open files here. It is safer (and faster) to
209 * reopen files one at a time as needed in read and write.
211 * FIXME: what about file locks? don't we need to reclaim them ASAP?
216 * Check if handle based operation so we know whether we can continue
217 * or not without returning to caller to reset file handle
219 switch (smb_command) {
220 case SMB_COM_READ_ANDX:
221 case SMB_COM_WRITE_ANDX:
223 case SMB_COM_FIND_CLOSE2:
224 case SMB_COM_LOCKING_ANDX:
228 unload_nls(nls_codepage);
232 /* Allocate and return pointer to an SMB request buffer, and set basic
233 SMB information in the SMB header. If the return code is zero, this
234 function must have filled in request_buf pointer */
236 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
241 rc = cifs_reconnect_tcon(tcon, smb_command);
245 *request_buf = cifs_small_buf_get();
246 if (*request_buf == NULL) {
247 /* BB should we add a retry in here if not a writepage? */
251 header_assemble((struct smb_hdr *) *request_buf, smb_command,
255 cifs_stats_inc(&tcon->num_smbs_sent);
261 small_smb_init_no_tc(const int smb_command, const int wct,
262 struct cifs_ses *ses, void **request_buf)
265 struct smb_hdr *buffer;
267 rc = small_smb_init(smb_command, wct, NULL, request_buf);
271 buffer = (struct smb_hdr *)*request_buf;
272 buffer->Mid = GetNextMid(ses->server);
273 if (ses->capabilities & CAP_UNICODE)
274 buffer->Flags2 |= SMBFLG2_UNICODE;
275 if (ses->capabilities & CAP_STATUS32)
276 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
278 /* uid, tid can stay at zero as set in header assemble */
280 /* BB add support for turning on the signing when
281 this function is used after 1st of session setup requests */
286 /* If the return code is zero, this function must fill in request_buf pointer */
288 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
289 void **request_buf, void **response_buf)
291 *request_buf = cifs_buf_get();
292 if (*request_buf == NULL) {
293 /* BB should we add a retry in here if not a writepage? */
296 /* Although the original thought was we needed the response buf for */
297 /* potential retries of smb operations it turns out we can determine */
298 /* from the mid flags when the request buffer can be resent without */
299 /* having to use a second distinct buffer for the response */
301 *response_buf = *request_buf;
303 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
307 cifs_stats_inc(&tcon->num_smbs_sent);
312 /* If the return code is zero, this function must fill in request_buf pointer */
314 smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
315 void **request_buf, void **response_buf)
319 rc = cifs_reconnect_tcon(tcon, smb_command);
323 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
327 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
328 void **request_buf, void **response_buf)
330 if (tcon->ses->need_reconnect || tcon->need_reconnect)
333 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
336 static int validate_t2(struct smb_t2_rsp *pSMB)
338 unsigned int total_size;
340 /* check for plausible wct */
341 if (pSMB->hdr.WordCount < 10)
344 /* check for parm and data offset going beyond end of smb */
345 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
346 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
349 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
350 if (total_size >= 512)
353 /* check that bcc is at least as big as parms + data, and that it is
354 * less than negotiated smb buffer
356 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
357 if (total_size > get_bcc(&pSMB->hdr) ||
358 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
363 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
364 sizeof(struct smb_t2_rsp) + 16);
368 static inline void inc_rfc1001_len(void *pSMB, int count)
370 struct smb_hdr *hdr = (struct smb_hdr *)pSMB;
372 be32_add_cpu(&hdr->smb_buf_length, count);
376 CIFSSMBNegotiate(unsigned int xid, struct cifs_ses *ses)
379 NEGOTIATE_RSP *pSMBr;
383 struct TCP_Server_Info *server;
385 unsigned int secFlags;
388 server = ses->server;
393 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
394 (void **) &pSMB, (void **) &pSMBr);
398 /* if any of auth flags (ie not sign or seal) are overriden use them */
399 if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
400 secFlags = ses->overrideSecFlg; /* BB FIXME fix sign flags? */
401 else /* if override flags set only sign/seal OR them with global auth */
402 secFlags = global_secflags | ses->overrideSecFlg;
404 cFYI(1, "secFlags 0x%x", secFlags);
406 pSMB->hdr.Mid = GetNextMid(server);
407 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
409 if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
410 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
411 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
412 cFYI(1, "Kerberos only mechanism, enable extended security");
413 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
414 } else if ((secFlags & CIFSSEC_MUST_NTLMSSP) == CIFSSEC_MUST_NTLMSSP)
415 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
416 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_NTLMSSP) {
417 cFYI(1, "NTLMSSP only mechanism, enable extended security");
418 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
422 for (i = 0; i < CIFS_NUM_PROT; i++) {
423 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
424 count += strlen(protocols[i].name) + 1;
425 /* null at end of source and target buffers anyway */
427 inc_rfc1001_len(pSMB, count);
428 pSMB->ByteCount = cpu_to_le16(count);
430 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
431 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
435 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
436 cFYI(1, "Dialect: %d", server->dialect);
437 /* Check wct = 1 error case */
438 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
439 /* core returns wct = 1, but we do not ask for core - otherwise
440 small wct just comes when dialect index is -1 indicating we
441 could not negotiate a common dialect */
444 #ifdef CONFIG_CIFS_WEAK_PW_HASH
445 } else if ((pSMBr->hdr.WordCount == 13)
446 && ((server->dialect == LANMAN_PROT)
447 || (server->dialect == LANMAN2_PROT))) {
449 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
451 if ((secFlags & CIFSSEC_MAY_LANMAN) ||
452 (secFlags & CIFSSEC_MAY_PLNTXT))
453 server->secType = LANMAN;
455 cERROR(1, "mount failed weak security disabled"
456 " in /proc/fs/cifs/SecurityFlags");
460 server->sec_mode = (__u8)le16_to_cpu(rsp->SecurityMode);
461 server->maxReq = min_t(unsigned int,
462 le16_to_cpu(rsp->MaxMpxCount),
464 cifs_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 cFYI(1, "SrvTime %d sec since 1970 (utc: %d) diff: %d",
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 cFYI(1, "server->timeAdj: %d seconds", 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(ses->server->cryptkey, rsp->EncryptionKey,
515 CIFS_CRYPTO_KEY_SIZE);
516 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
517 rc = -EIO; /* need cryptkey unless plain text */
521 cFYI(1, "LANMAN negotiated");
522 /* we will not end up setting signing flags - as no signing
523 was in LANMAN and server did not return the flags on */
525 #else /* weak security disabled */
526 } else if (pSMBr->hdr.WordCount == 13) {
527 cERROR(1, "mount failed, cifs module not built "
528 "with CIFS_WEAK_PW_HASH support");
530 #endif /* WEAK_PW_HASH */
532 } else if (pSMBr->hdr.WordCount != 17) {
537 /* else wct == 17 NTLM */
538 server->sec_mode = pSMBr->SecurityMode;
539 if ((server->sec_mode & SECMODE_USER) == 0)
540 cFYI(1, "share mode security");
542 if ((server->sec_mode & SECMODE_PW_ENCRYPT) == 0)
543 #ifdef CONFIG_CIFS_WEAK_PW_HASH
544 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
545 #endif /* CIFS_WEAK_PW_HASH */
546 cERROR(1, "Server requests plain text password"
547 " but client support disabled");
549 if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
550 server->secType = NTLMv2;
551 else if (secFlags & CIFSSEC_MAY_NTLM)
552 server->secType = NTLM;
553 else if (secFlags & CIFSSEC_MAY_NTLMV2)
554 server->secType = NTLMv2;
555 else if (secFlags & CIFSSEC_MAY_KRB5)
556 server->secType = Kerberos;
557 else if (secFlags & CIFSSEC_MAY_NTLMSSP)
558 server->secType = RawNTLMSSP;
559 else if (secFlags & CIFSSEC_MAY_LANMAN)
560 server->secType = LANMAN;
563 cERROR(1, "Invalid security type");
566 /* else ... any others ...? */
568 /* one byte, so no need to convert this or EncryptionKeyLen from
570 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
572 cifs_set_credits(server, server->maxReq);
573 /* probably no need to store and check maxvcs */
574 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
575 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
576 cFYI(DBG2, "Max buf = %d", ses->server->maxBuf);
577 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
578 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
579 server->timeAdj *= 60;
580 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
581 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
582 CIFS_CRYPTO_KEY_SIZE);
583 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
584 server->capabilities & CAP_EXTENDED_SECURITY) &&
585 (pSMBr->EncryptionKeyLength == 0)) {
586 /* decode security blob */
587 count = get_bcc(&pSMBr->hdr);
592 spin_lock(&cifs_tcp_ses_lock);
593 if (server->srv_count > 1) {
594 spin_unlock(&cifs_tcp_ses_lock);
595 if (memcmp(server->server_GUID,
596 pSMBr->u.extended_response.
598 cFYI(1, "server UID changed");
599 memcpy(server->server_GUID,
600 pSMBr->u.extended_response.GUID,
604 spin_unlock(&cifs_tcp_ses_lock);
605 memcpy(server->server_GUID,
606 pSMBr->u.extended_response.GUID, 16);
610 server->secType = RawNTLMSSP;
612 rc = decode_negTokenInit(pSMBr->u.extended_response.
613 SecurityBlob, count - 16,
619 if (server->secType == Kerberos) {
620 if (!server->sec_kerberos &&
621 !server->sec_mskerberos)
623 } else if (server->secType == RawNTLMSSP) {
624 if (!server->sec_ntlmssp)
629 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
630 rc = -EIO; /* no crypt key only if plain text pwd */
633 server->capabilities &= ~CAP_EXTENDED_SECURITY;
635 #ifdef CONFIG_CIFS_WEAK_PW_HASH
638 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
639 /* MUST_SIGN already includes the MAY_SIGN FLAG
640 so if this is zero it means that signing is disabled */
641 cFYI(1, "Signing disabled");
642 if (server->sec_mode & SECMODE_SIGN_REQUIRED) {
643 cERROR(1, "Server requires "
644 "packet signing to be enabled in "
645 "/proc/fs/cifs/SecurityFlags.");
649 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
650 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
651 /* signing required */
652 cFYI(1, "Must sign - secFlags 0x%x", secFlags);
653 if ((server->sec_mode &
654 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
655 cERROR(1, "signing required but server lacks support");
658 server->sec_mode |= SECMODE_SIGN_REQUIRED;
660 /* signing optional ie CIFSSEC_MAY_SIGN */
661 if ((server->sec_mode & SECMODE_SIGN_REQUIRED) == 0)
663 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
667 cifs_buf_release(pSMB);
669 cFYI(1, "negprot rc %d", rc);
674 CIFSSMBTDis(const int xid, struct cifs_tcon *tcon)
676 struct smb_hdr *smb_buffer;
679 cFYI(1, "In tree disconnect");
681 /* BB: do we need to check this? These should never be NULL. */
682 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
686 * No need to return error on this operation if tid invalidated and
687 * closed on server already e.g. due to tcp session crashing. Also,
688 * the tcon is no longer on the list, so no need to take lock before
691 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
694 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
695 (void **)&smb_buffer);
699 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
701 cFYI(1, "Tree disconnect failed %d", rc);
703 /* No need to return error on this operation if tid invalidated and
704 closed on server already e.g. due to tcp session crashing */
712 * This is a no-op for now. We're not really interested in the reply, but
713 * rather in the fact that the server sent one and that server->lstrp
716 * FIXME: maybe we should consider checking that the reply matches request?
719 cifs_echo_callback(struct mid_q_entry *mid)
721 struct TCP_Server_Info *server = mid->callback_data;
723 DeleteMidQEntry(mid);
724 cifs_add_credits(server, 1);
728 CIFSSMBEcho(struct TCP_Server_Info *server)
734 cFYI(1, "In echo request");
736 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
740 /* set up echo request */
741 smb->hdr.Tid = 0xffff;
742 smb->hdr.WordCount = 1;
743 put_unaligned_le16(1, &smb->EchoCount);
744 put_bcc(1, &smb->hdr);
746 inc_rfc1001_len(smb, 3);
748 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
750 rc = cifs_call_async(server, &iov, 1, NULL, cifs_echo_callback,
753 cFYI(1, "Echo request failed: %d", rc);
755 cifs_small_buf_release(smb);
761 CIFSSMBLogoff(const int xid, struct cifs_ses *ses)
763 LOGOFF_ANDX_REQ *pSMB;
766 cFYI(1, "In SMBLogoff for session disconnect");
769 * BB: do we need to check validity of ses and server? They should
770 * always be valid since we have an active reference. If not, that
771 * should probably be a BUG()
773 if (!ses || !ses->server)
776 mutex_lock(&ses->session_mutex);
777 if (ses->need_reconnect)
778 goto session_already_dead; /* no need to send SMBlogoff if uid
779 already closed due to reconnect */
780 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
782 mutex_unlock(&ses->session_mutex);
786 pSMB->hdr.Mid = GetNextMid(ses->server);
788 if (ses->server->sec_mode &
789 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
790 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
792 pSMB->hdr.Uid = ses->Suid;
794 pSMB->AndXCommand = 0xFF;
795 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
796 session_already_dead:
797 mutex_unlock(&ses->session_mutex);
799 /* if session dead then we do not need to do ulogoff,
800 since server closed smb session, no sense reporting
808 CIFSPOSIXDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
809 __u16 type, const struct nls_table *nls_codepage, int remap)
811 TRANSACTION2_SPI_REQ *pSMB = NULL;
812 TRANSACTION2_SPI_RSP *pSMBr = NULL;
813 struct unlink_psx_rq *pRqD;
816 int bytes_returned = 0;
817 __u16 params, param_offset, offset, byte_count;
819 cFYI(1, "In POSIX delete");
821 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
826 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
828 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
829 PATH_MAX, nls_codepage, remap);
830 name_len++; /* trailing null */
832 } else { /* BB add path length overrun check */
833 name_len = strnlen(fileName, PATH_MAX);
834 name_len++; /* trailing null */
835 strncpy(pSMB->FileName, fileName, name_len);
838 params = 6 + name_len;
839 pSMB->MaxParameterCount = cpu_to_le16(2);
840 pSMB->MaxDataCount = 0; /* BB double check this with jra */
841 pSMB->MaxSetupCount = 0;
846 param_offset = offsetof(struct smb_com_transaction2_spi_req,
847 InformationLevel) - 4;
848 offset = param_offset + params;
850 /* Setup pointer to Request Data (inode type) */
851 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
852 pRqD->type = cpu_to_le16(type);
853 pSMB->ParameterOffset = cpu_to_le16(param_offset);
854 pSMB->DataOffset = cpu_to_le16(offset);
855 pSMB->SetupCount = 1;
857 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
858 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
860 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
861 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
862 pSMB->ParameterCount = cpu_to_le16(params);
863 pSMB->TotalParameterCount = pSMB->ParameterCount;
864 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
866 inc_rfc1001_len(pSMB, byte_count);
867 pSMB->ByteCount = cpu_to_le16(byte_count);
868 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
869 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
871 cFYI(1, "Posix delete returned %d", rc);
872 cifs_buf_release(pSMB);
874 cifs_stats_inc(&tcon->num_deletes);
883 CIFSSMBDelFile(const int xid, struct cifs_tcon *tcon, const char *fileName,
884 const struct nls_table *nls_codepage, int remap)
886 DELETE_FILE_REQ *pSMB = NULL;
887 DELETE_FILE_RSP *pSMBr = NULL;
893 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
898 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
900 cifsConvertToUTF16((__le16 *) pSMB->fileName, fileName,
901 PATH_MAX, nls_codepage, remap);
902 name_len++; /* trailing null */
904 } else { /* BB improve check for buffer overruns BB */
905 name_len = strnlen(fileName, PATH_MAX);
906 name_len++; /* trailing null */
907 strncpy(pSMB->fileName, fileName, name_len);
909 pSMB->SearchAttributes =
910 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
911 pSMB->BufferFormat = 0x04;
912 inc_rfc1001_len(pSMB, name_len + 1);
913 pSMB->ByteCount = cpu_to_le16(name_len + 1);
914 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
915 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
916 cifs_stats_inc(&tcon->num_deletes);
918 cFYI(1, "Error in RMFile = %d", rc);
920 cifs_buf_release(pSMB);
928 CIFSSMBRmDir(const int xid, struct cifs_tcon *tcon, const char *dirName,
929 const struct nls_table *nls_codepage, int remap)
931 DELETE_DIRECTORY_REQ *pSMB = NULL;
932 DELETE_DIRECTORY_RSP *pSMBr = NULL;
937 cFYI(1, "In CIFSSMBRmDir");
939 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
944 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
945 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, dirName,
946 PATH_MAX, nls_codepage, remap);
947 name_len++; /* trailing null */
949 } else { /* BB improve check for buffer overruns BB */
950 name_len = strnlen(dirName, PATH_MAX);
951 name_len++; /* trailing null */
952 strncpy(pSMB->DirName, dirName, name_len);
955 pSMB->BufferFormat = 0x04;
956 inc_rfc1001_len(pSMB, name_len + 1);
957 pSMB->ByteCount = cpu_to_le16(name_len + 1);
958 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
959 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
960 cifs_stats_inc(&tcon->num_rmdirs);
962 cFYI(1, "Error in RMDir = %d", rc);
964 cifs_buf_release(pSMB);
971 CIFSSMBMkDir(const int xid, struct cifs_tcon *tcon,
972 const char *name, const struct nls_table *nls_codepage, int remap)
975 CREATE_DIRECTORY_REQ *pSMB = NULL;
976 CREATE_DIRECTORY_RSP *pSMBr = NULL;
980 cFYI(1, "In CIFSSMBMkDir");
982 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
987 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
988 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
989 PATH_MAX, nls_codepage, remap);
990 name_len++; /* trailing null */
992 } else { /* BB improve check for buffer overruns BB */
993 name_len = strnlen(name, PATH_MAX);
994 name_len++; /* trailing null */
995 strncpy(pSMB->DirName, name, name_len);
998 pSMB->BufferFormat = 0x04;
999 inc_rfc1001_len(pSMB, name_len + 1);
1000 pSMB->ByteCount = cpu_to_le16(name_len + 1);
1001 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1002 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1003 cifs_stats_inc(&tcon->num_mkdirs);
1005 cFYI(1, "Error in Mkdir = %d", rc);
1007 cifs_buf_release(pSMB);
1014 CIFSPOSIXCreate(const int xid, struct cifs_tcon *tcon, __u32 posix_flags,
1015 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
1016 __u32 *pOplock, const char *name,
1017 const struct nls_table *nls_codepage, int remap)
1019 TRANSACTION2_SPI_REQ *pSMB = NULL;
1020 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1023 int bytes_returned = 0;
1024 __u16 params, param_offset, offset, byte_count, count;
1025 OPEN_PSX_REQ *pdata;
1026 OPEN_PSX_RSP *psx_rsp;
1028 cFYI(1, "In POSIX Create");
1030 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1035 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1037 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1038 PATH_MAX, nls_codepage, remap);
1039 name_len++; /* trailing null */
1041 } else { /* BB improve the check for buffer overruns BB */
1042 name_len = strnlen(name, PATH_MAX);
1043 name_len++; /* trailing null */
1044 strncpy(pSMB->FileName, name, name_len);
1047 params = 6 + name_len;
1048 count = sizeof(OPEN_PSX_REQ);
1049 pSMB->MaxParameterCount = cpu_to_le16(2);
1050 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1051 pSMB->MaxSetupCount = 0;
1055 pSMB->Reserved2 = 0;
1056 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1057 InformationLevel) - 4;
1058 offset = param_offset + params;
1059 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1060 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1061 pdata->Permissions = cpu_to_le64(mode);
1062 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1063 pdata->OpenFlags = cpu_to_le32(*pOplock);
1064 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1065 pSMB->DataOffset = cpu_to_le16(offset);
1066 pSMB->SetupCount = 1;
1067 pSMB->Reserved3 = 0;
1068 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1069 byte_count = 3 /* pad */ + params + count;
1071 pSMB->DataCount = cpu_to_le16(count);
1072 pSMB->ParameterCount = cpu_to_le16(params);
1073 pSMB->TotalDataCount = pSMB->DataCount;
1074 pSMB->TotalParameterCount = pSMB->ParameterCount;
1075 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1076 pSMB->Reserved4 = 0;
1077 inc_rfc1001_len(pSMB, byte_count);
1078 pSMB->ByteCount = cpu_to_le16(byte_count);
1079 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1080 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1082 cFYI(1, "Posix create returned %d", rc);
1083 goto psx_create_err;
1086 cFYI(1, "copying inode info");
1087 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1089 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
1090 rc = -EIO; /* bad smb */
1091 goto psx_create_err;
1094 /* copy return information to pRetData */
1095 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1096 + le16_to_cpu(pSMBr->t2.DataOffset));
1098 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1100 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1101 /* Let caller know file was created so we can set the mode. */
1102 /* Do we care about the CreateAction in any other cases? */
1103 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1104 *pOplock |= CIFS_CREATE_ACTION;
1105 /* check to make sure response data is there */
1106 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1107 pRetData->Type = cpu_to_le32(-1); /* unknown */
1108 cFYI(DBG2, "unknown type");
1110 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
1111 + sizeof(FILE_UNIX_BASIC_INFO)) {
1112 cERROR(1, "Open response data too small");
1113 pRetData->Type = cpu_to_le32(-1);
1114 goto psx_create_err;
1116 memcpy((char *) pRetData,
1117 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1118 sizeof(FILE_UNIX_BASIC_INFO));
1122 cifs_buf_release(pSMB);
1124 if (posix_flags & SMB_O_DIRECTORY)
1125 cifs_stats_inc(&tcon->num_posixmkdirs);
1127 cifs_stats_inc(&tcon->num_posixopens);
1135 static __u16 convert_disposition(int disposition)
1139 switch (disposition) {
1140 case FILE_SUPERSEDE:
1141 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1144 ofun = SMBOPEN_OAPPEND;
1147 ofun = SMBOPEN_OCREATE;
1150 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1152 case FILE_OVERWRITE:
1153 ofun = SMBOPEN_OTRUNC;
1155 case FILE_OVERWRITE_IF:
1156 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1159 cFYI(1, "unknown disposition %d", disposition);
1160 ofun = SMBOPEN_OAPPEND; /* regular open */
1166 access_flags_to_smbopen_mode(const int access_flags)
1168 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1170 if (masked_flags == GENERIC_READ)
1171 return SMBOPEN_READ;
1172 else if (masked_flags == GENERIC_WRITE)
1173 return SMBOPEN_WRITE;
1175 /* just go for read/write */
1176 return SMBOPEN_READWRITE;
1180 SMBLegacyOpen(const int xid, struct cifs_tcon *tcon,
1181 const char *fileName, const int openDisposition,
1182 const int access_flags, const int create_options, __u16 *netfid,
1183 int *pOplock, FILE_ALL_INFO *pfile_info,
1184 const struct nls_table *nls_codepage, int remap)
1187 OPENX_REQ *pSMB = NULL;
1188 OPENX_RSP *pSMBr = NULL;
1194 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1199 pSMB->AndXCommand = 0xFF; /* none */
1201 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1202 count = 1; /* account for one byte pad to word boundary */
1204 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1205 fileName, PATH_MAX, nls_codepage, remap);
1206 name_len++; /* trailing null */
1208 } else { /* BB improve check for buffer overruns BB */
1209 count = 0; /* no pad */
1210 name_len = strnlen(fileName, PATH_MAX);
1211 name_len++; /* trailing null */
1212 strncpy(pSMB->fileName, fileName, name_len);
1214 if (*pOplock & REQ_OPLOCK)
1215 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1216 else if (*pOplock & REQ_BATCHOPLOCK)
1217 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1219 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1220 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1221 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1222 /* set file as system file if special file such
1223 as fifo and server expecting SFU style and
1224 no Unix extensions */
1226 if (create_options & CREATE_OPTION_SPECIAL)
1227 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1228 else /* BB FIXME BB */
1229 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1231 if (create_options & CREATE_OPTION_READONLY)
1232 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1235 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1236 CREATE_OPTIONS_MASK); */
1237 /* BB FIXME END BB */
1239 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1240 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1242 inc_rfc1001_len(pSMB, count);
1244 pSMB->ByteCount = cpu_to_le16(count);
1245 /* long_op set to 1 to allow for oplock break timeouts */
1246 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1247 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1248 cifs_stats_inc(&tcon->num_opens);
1250 cFYI(1, "Error in Open = %d", rc);
1252 /* BB verify if wct == 15 */
1254 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1256 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1257 /* Let caller know file was created so we can set the mode. */
1258 /* Do we care about the CreateAction in any other cases? */
1260 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1261 *pOplock |= CIFS_CREATE_ACTION; */
1265 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1266 pfile_info->LastAccessTime = 0; /* BB fixme */
1267 pfile_info->LastWriteTime = 0; /* BB fixme */
1268 pfile_info->ChangeTime = 0; /* BB fixme */
1269 pfile_info->Attributes =
1270 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1271 /* the file_info buf is endian converted by caller */
1272 pfile_info->AllocationSize =
1273 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1274 pfile_info->EndOfFile = pfile_info->AllocationSize;
1275 pfile_info->NumberOfLinks = cpu_to_le32(1);
1276 pfile_info->DeletePending = 0;
1280 cifs_buf_release(pSMB);
1287 CIFSSMBOpen(const int xid, struct cifs_tcon *tcon,
1288 const char *fileName, const int openDisposition,
1289 const int access_flags, const int create_options, __u16 *netfid,
1290 int *pOplock, FILE_ALL_INFO *pfile_info,
1291 const struct nls_table *nls_codepage, int remap)
1294 OPEN_REQ *pSMB = NULL;
1295 OPEN_RSP *pSMBr = NULL;
1301 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1306 pSMB->AndXCommand = 0xFF; /* none */
1308 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1309 count = 1; /* account for one byte pad to word boundary */
1311 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1312 fileName, PATH_MAX, nls_codepage, remap);
1313 name_len++; /* trailing null */
1315 pSMB->NameLength = cpu_to_le16(name_len);
1316 } else { /* BB improve check for buffer overruns BB */
1317 count = 0; /* no pad */
1318 name_len = strnlen(fileName, PATH_MAX);
1319 name_len++; /* trailing null */
1320 pSMB->NameLength = cpu_to_le16(name_len);
1321 strncpy(pSMB->fileName, fileName, name_len);
1323 if (*pOplock & REQ_OPLOCK)
1324 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1325 else if (*pOplock & REQ_BATCHOPLOCK)
1326 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1327 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1328 pSMB->AllocationSize = 0;
1329 /* set file as system file if special file such
1330 as fifo and server expecting SFU style and
1331 no Unix extensions */
1332 if (create_options & CREATE_OPTION_SPECIAL)
1333 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1335 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1337 /* XP does not handle ATTR_POSIX_SEMANTICS */
1338 /* but it helps speed up case sensitive checks for other
1339 servers such as Samba */
1340 if (tcon->ses->capabilities & CAP_UNIX)
1341 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1343 if (create_options & CREATE_OPTION_READONLY)
1344 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1346 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1347 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1348 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1349 /* BB Expirement with various impersonation levels and verify */
1350 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1351 pSMB->SecurityFlags =
1352 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1355 inc_rfc1001_len(pSMB, count);
1357 pSMB->ByteCount = cpu_to_le16(count);
1358 /* long_op set to 1 to allow for oplock break timeouts */
1359 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1360 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1361 cifs_stats_inc(&tcon->num_opens);
1363 cFYI(1, "Error in Open = %d", rc);
1365 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1366 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1367 /* Let caller know file was created so we can set the mode. */
1368 /* Do we care about the CreateAction in any other cases? */
1369 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1370 *pOplock |= CIFS_CREATE_ACTION;
1372 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1373 36 /* CreationTime to Attributes */);
1374 /* the file_info buf is endian converted by caller */
1375 pfile_info->AllocationSize = pSMBr->AllocationSize;
1376 pfile_info->EndOfFile = pSMBr->EndOfFile;
1377 pfile_info->NumberOfLinks = cpu_to_le32(1);
1378 pfile_info->DeletePending = 0;
1382 cifs_buf_release(pSMB);
1388 struct cifs_readdata *
1389 cifs_readdata_alloc(unsigned int nr_pages)
1391 struct cifs_readdata *rdata;
1393 /* readdata + 1 kvec for each page */
1394 rdata = kzalloc(sizeof(*rdata) +
1395 sizeof(struct kvec) * nr_pages, GFP_KERNEL);
1396 if (rdata != NULL) {
1397 INIT_WORK(&rdata->work, cifs_readv_complete);
1398 INIT_LIST_HEAD(&rdata->pages);
1404 cifs_readdata_free(struct cifs_readdata *rdata)
1406 cifsFileInfo_put(rdata->cfile);
1411 * Discard any remaining data in the current SMB. To do this, we borrow the
1415 cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1417 READ_RSP *rsp = (READ_RSP *)server->smallbuf;
1418 unsigned int rfclen = be32_to_cpu(rsp->hdr.smb_buf_length);
1419 int remaining = rfclen + 4 - server->total_read;
1420 struct cifs_readdata *rdata = mid->callback_data;
1422 while (remaining > 0) {
1425 length = cifs_read_from_socket(server, server->bigbuf,
1426 min_t(unsigned int, remaining,
1427 CIFSMaxBufSize + MAX_CIFS_HDR_SIZE));
1430 server->total_read += length;
1431 remaining -= length;
1434 dequeue_mid(mid, rdata->result);
1439 cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1442 unsigned int data_offset, remaining, data_len;
1443 struct cifs_readdata *rdata = mid->callback_data;
1444 READ_RSP *rsp = (READ_RSP *)server->smallbuf;
1445 unsigned int rfclen = be32_to_cpu(rsp->hdr.smb_buf_length) + 4;
1448 struct page *page, *tpage;
1450 cFYI(1, "%s: mid=%u offset=%llu bytes=%u", __func__,
1451 mid->mid, rdata->offset, rdata->bytes);
1454 * read the rest of READ_RSP header (sans Data array), or whatever we
1455 * can if there's not enough data. At this point, we've read down to
1458 len = min_t(unsigned int, rfclen, sizeof(*rsp)) -
1459 sizeof(struct smb_hdr) + 1;
1461 rdata->iov[0].iov_base = server->smallbuf + sizeof(struct smb_hdr) - 1;
1462 rdata->iov[0].iov_len = len;
1464 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1467 server->total_read += length;
1469 /* Was the SMB read successful? */
1470 rdata->result = map_smb_to_linux_error(&rsp->hdr, false);
1471 if (rdata->result != 0) {
1472 cFYI(1, "%s: server returned error %d", __func__,
1474 return cifs_readv_discard(server, mid);
1477 /* Is there enough to get to the rest of the READ_RSP header? */
1478 if (server->total_read < sizeof(READ_RSP)) {
1479 cFYI(1, "%s: server returned short header. got=%u expected=%zu",
1480 __func__, server->total_read, sizeof(READ_RSP));
1481 rdata->result = -EIO;
1482 return cifs_readv_discard(server, mid);
1485 data_offset = le16_to_cpu(rsp->DataOffset) + 4;
1486 if (data_offset < server->total_read) {
1488 * win2k8 sometimes sends an offset of 0 when the read
1489 * is beyond the EOF. Treat it as if the data starts just after
1492 cFYI(1, "%s: data offset (%u) inside read response header",
1493 __func__, data_offset);
1494 data_offset = server->total_read;
1495 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1496 /* data_offset is beyond the end of smallbuf */
1497 cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
1498 __func__, data_offset);
1499 rdata->result = -EIO;
1500 return cifs_readv_discard(server, mid);
1503 cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
1504 server->total_read, data_offset);
1506 len = data_offset - server->total_read;
1508 /* read any junk before data into the rest of smallbuf */
1509 rdata->iov[0].iov_base = server->smallbuf + server->total_read;
1510 rdata->iov[0].iov_len = len;
1511 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1514 server->total_read += length;
1517 /* set up first iov for signature check */
1518 rdata->iov[0].iov_base = server->smallbuf;
1519 rdata->iov[0].iov_len = server->total_read;
1520 cFYI(1, "0: iov_base=%p iov_len=%zu",
1521 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1523 /* how much data is in the response? */
1524 data_len = le16_to_cpu(rsp->DataLengthHigh) << 16;
1525 data_len += le16_to_cpu(rsp->DataLength);
1526 if (data_offset + data_len > rfclen) {
1527 /* data_len is corrupt -- discard frame */
1528 rdata->result = -EIO;
1529 return cifs_readv_discard(server, mid);
1532 /* marshal up the page array */
1534 remaining = data_len;
1537 /* determine the eof that the server (probably) has */
1538 eof = CIFS_I(rdata->mapping->host)->server_eof;
1539 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
1540 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
1542 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1543 if (remaining >= PAGE_CACHE_SIZE) {
1544 /* enough data to fill the page */
1545 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1546 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
1547 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1548 rdata->nr_iov, page->index,
1549 rdata->iov[rdata->nr_iov].iov_base,
1550 rdata->iov[rdata->nr_iov].iov_len);
1552 len += PAGE_CACHE_SIZE;
1553 remaining -= PAGE_CACHE_SIZE;
1554 } else if (remaining > 0) {
1555 /* enough for partial page, fill and zero the rest */
1556 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1557 rdata->iov[rdata->nr_iov].iov_len = remaining;
1558 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1559 rdata->nr_iov, page->index,
1560 rdata->iov[rdata->nr_iov].iov_base,
1561 rdata->iov[rdata->nr_iov].iov_len);
1562 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
1563 '\0', PAGE_CACHE_SIZE - remaining);
1567 } else if (page->index > eof_index) {
1569 * The VFS will not try to do readahead past the
1570 * i_size, but it's possible that we have outstanding
1571 * writes with gaps in the middle and the i_size hasn't
1572 * caught up yet. Populate those with zeroed out pages
1573 * to prevent the VFS from repeatedly attempting to
1574 * fill them until the writes are flushed.
1576 zero_user(page, 0, PAGE_CACHE_SIZE);
1577 list_del(&page->lru);
1578 lru_cache_add_file(page);
1579 flush_dcache_page(page);
1580 SetPageUptodate(page);
1582 page_cache_release(page);
1584 /* no need to hold page hostage */
1585 list_del(&page->lru);
1586 lru_cache_add_file(page);
1588 page_cache_release(page);
1592 /* issue the read if we have any iovecs left to fill */
1593 if (rdata->nr_iov > 1) {
1594 length = cifs_readv_from_socket(server, &rdata->iov[1],
1595 rdata->nr_iov - 1, len);
1598 server->total_read += length;
1603 rdata->bytes = length;
1605 cFYI(1, "total_read=%u rfclen=%u remaining=%u", server->total_read,
1608 /* discard anything left over */
1609 if (server->total_read < rfclen)
1610 return cifs_readv_discard(server, mid);
1612 dequeue_mid(mid, false);
1617 cifs_readv_complete(struct work_struct *work)
1619 struct cifs_readdata *rdata = container_of(work,
1620 struct cifs_readdata, work);
1621 struct page *page, *tpage;
1623 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1624 list_del(&page->lru);
1625 lru_cache_add_file(page);
1627 if (rdata->result == 0) {
1629 flush_dcache_page(page);
1630 SetPageUptodate(page);
1635 if (rdata->result == 0)
1636 cifs_readpage_to_fscache(rdata->mapping->host, page);
1638 page_cache_release(page);
1640 cifs_readdata_free(rdata);
1644 cifs_readv_callback(struct mid_q_entry *mid)
1646 struct cifs_readdata *rdata = mid->callback_data;
1647 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1648 struct TCP_Server_Info *server = tcon->ses->server;
1650 cFYI(1, "%s: mid=%u state=%d result=%d bytes=%u", __func__,
1651 mid->mid, mid->midState, rdata->result, rdata->bytes);
1653 switch (mid->midState) {
1654 case MID_RESPONSE_RECEIVED:
1655 /* result already set, check signature */
1656 if (server->sec_mode &
1657 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1658 if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
1659 server, mid->sequence_number + 1))
1660 cERROR(1, "Unexpected SMB signature");
1662 /* FIXME: should this be counted toward the initiating task? */
1663 task_io_account_read(rdata->bytes);
1664 cifs_stats_bytes_read(tcon, rdata->bytes);
1666 case MID_REQUEST_SUBMITTED:
1667 case MID_RETRY_NEEDED:
1668 rdata->result = -EAGAIN;
1671 rdata->result = -EIO;
1674 queue_work(system_nrt_wq, &rdata->work);
1675 DeleteMidQEntry(mid);
1676 cifs_add_credits(server, 1);
1679 /* cifs_async_readv - send an async write, and set up mid to handle result */
1681 cifs_async_readv(struct cifs_readdata *rdata)
1684 READ_REQ *smb = NULL;
1686 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1688 cFYI(1, "%s: offset=%llu bytes=%u", __func__,
1689 rdata->offset, rdata->bytes);
1691 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1694 wct = 10; /* old style read */
1695 if ((rdata->offset >> 32) > 0) {
1696 /* can not handle this big offset for old */
1701 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1705 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1706 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1708 smb->AndXCommand = 0xFF; /* none */
1709 smb->Fid = rdata->cfile->netfid;
1710 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1712 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1714 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1715 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1719 /* old style read */
1720 struct smb_com_readx_req *smbr =
1721 (struct smb_com_readx_req *)smb;
1722 smbr->ByteCount = 0;
1725 /* 4 for RFC1001 length + 1 for BCC */
1726 rdata->iov[0].iov_base = smb;
1727 rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1729 rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
1730 cifs_readv_receive, cifs_readv_callback,
1734 cifs_stats_inc(&tcon->num_reads);
1736 cifs_small_buf_release(smb);
1741 CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
1742 char **buf, int *pbuf_type)
1745 READ_REQ *pSMB = NULL;
1746 READ_RSP *pSMBr = NULL;
1747 char *pReadData = NULL;
1749 int resp_buf_type = 0;
1751 __u32 pid = io_parms->pid;
1752 __u16 netfid = io_parms->netfid;
1753 __u64 offset = io_parms->offset;
1754 struct cifs_tcon *tcon = io_parms->tcon;
1755 unsigned int count = io_parms->length;
1757 cFYI(1, "Reading %d bytes on fid %d", count, netfid);
1758 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1761 wct = 10; /* old style read */
1762 if ((offset >> 32) > 0) {
1763 /* can not handle this big offset for old */
1769 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1773 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1774 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1776 /* tcon and ses pointer are checked in smb_init */
1777 if (tcon->ses->server == NULL)
1778 return -ECONNABORTED;
1780 pSMB->AndXCommand = 0xFF; /* none */
1782 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1784 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1786 pSMB->Remaining = 0;
1787 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1788 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1790 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1792 /* old style read */
1793 struct smb_com_readx_req *pSMBW =
1794 (struct smb_com_readx_req *)pSMB;
1795 pSMBW->ByteCount = 0;
1798 iov[0].iov_base = (char *)pSMB;
1799 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1800 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1801 &resp_buf_type, CIFS_LOG_ERROR);
1802 cifs_stats_inc(&tcon->num_reads);
1803 pSMBr = (READ_RSP *)iov[0].iov_base;
1805 cERROR(1, "Send error in read = %d", rc);
1807 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1808 data_length = data_length << 16;
1809 data_length += le16_to_cpu(pSMBr->DataLength);
1810 *nbytes = data_length;
1812 /*check that DataLength would not go beyond end of SMB */
1813 if ((data_length > CIFSMaxBufSize)
1814 || (data_length > count)) {
1815 cFYI(1, "bad length %d for count %d",
1816 data_length, count);
1820 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1821 le16_to_cpu(pSMBr->DataOffset);
1822 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1823 cERROR(1, "Faulting on read rc = %d",rc);
1825 }*/ /* can not use copy_to_user when using page cache*/
1827 memcpy(*buf, pReadData, data_length);
1831 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1833 if (resp_buf_type == CIFS_SMALL_BUFFER)
1834 cifs_small_buf_release(iov[0].iov_base);
1835 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1836 cifs_buf_release(iov[0].iov_base);
1837 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1838 /* return buffer to caller to free */
1839 *buf = iov[0].iov_base;
1840 if (resp_buf_type == CIFS_SMALL_BUFFER)
1841 *pbuf_type = CIFS_SMALL_BUFFER;
1842 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1843 *pbuf_type = CIFS_LARGE_BUFFER;
1844 } /* else no valid buffer on return - leave as null */
1846 /* Note: On -EAGAIN error only caller can retry on handle based calls
1847 since file handle passed in no longer valid */
1853 CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
1854 unsigned int *nbytes, const char *buf,
1855 const char __user *ubuf, const int long_op)
1858 WRITE_REQ *pSMB = NULL;
1859 WRITE_RSP *pSMBr = NULL;
1860 int bytes_returned, wct;
1863 __u32 pid = io_parms->pid;
1864 __u16 netfid = io_parms->netfid;
1865 __u64 offset = io_parms->offset;
1866 struct cifs_tcon *tcon = io_parms->tcon;
1867 unsigned int count = io_parms->length;
1871 /* cFYI(1, "write at %lld %d bytes", offset, count);*/
1872 if (tcon->ses == NULL)
1873 return -ECONNABORTED;
1875 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1879 if ((offset >> 32) > 0) {
1880 /* can not handle big offset for old srv */
1885 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1890 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1891 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1893 /* tcon and ses pointer are checked in smb_init */
1894 if (tcon->ses->server == NULL)
1895 return -ECONNABORTED;
1897 pSMB->AndXCommand = 0xFF; /* none */
1899 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1901 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1903 pSMB->Reserved = 0xFFFFFFFF;
1904 pSMB->WriteMode = 0;
1905 pSMB->Remaining = 0;
1907 /* Can increase buffer size if buffer is big enough in some cases ie we
1908 can send more if LARGE_WRITE_X capability returned by the server and if
1909 our buffer is big enough or if we convert to iovecs on socket writes
1910 and eliminate the copy to the CIFS buffer */
1911 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1912 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1914 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1918 if (bytes_sent > count)
1921 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1923 memcpy(pSMB->Data, buf, bytes_sent);
1925 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1926 cifs_buf_release(pSMB);
1929 } else if (count != 0) {
1931 cifs_buf_release(pSMB);
1933 } /* else setting file size with write of zero bytes */
1935 byte_count = bytes_sent + 1; /* pad */
1936 else /* wct == 12 */
1937 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1939 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1940 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1941 inc_rfc1001_len(pSMB, byte_count);
1944 pSMB->ByteCount = cpu_to_le16(byte_count);
1945 else { /* old style write has byte count 4 bytes earlier
1947 struct smb_com_writex_req *pSMBW =
1948 (struct smb_com_writex_req *)pSMB;
1949 pSMBW->ByteCount = cpu_to_le16(byte_count);
1952 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1953 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1954 cifs_stats_inc(&tcon->num_writes);
1956 cFYI(1, "Send error in write = %d", rc);
1958 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1959 *nbytes = (*nbytes) << 16;
1960 *nbytes += le16_to_cpu(pSMBr->Count);
1963 * Mask off high 16 bits when bytes written as returned by the
1964 * server is greater than bytes requested by the client. Some
1965 * OS/2 servers are known to set incorrect CountHigh values.
1967 if (*nbytes > count)
1971 cifs_buf_release(pSMB);
1973 /* Note: On -EAGAIN error only caller can retry on handle based calls
1974 since file handle passed in no longer valid */
1980 cifs_writedata_release(struct kref *refcount)
1982 struct cifs_writedata *wdata = container_of(refcount,
1983 struct cifs_writedata, refcount);
1986 cifsFileInfo_put(wdata->cfile);
1992 * Write failed with a retryable error. Resend the write request. It's also
1993 * possible that the page was redirtied so re-clean the page.
1996 cifs_writev_requeue(struct cifs_writedata *wdata)
1999 struct inode *inode = wdata->cfile->dentry->d_inode;
2001 for (i = 0; i < wdata->nr_pages; i++) {
2002 lock_page(wdata->pages[i]);
2003 clear_page_dirty_for_io(wdata->pages[i]);
2007 rc = cifs_async_writev(wdata);
2008 } while (rc == -EAGAIN);
2010 for (i = 0; i < wdata->nr_pages; i++) {
2012 SetPageError(wdata->pages[i]);
2013 unlock_page(wdata->pages[i]);
2016 mapping_set_error(inode->i_mapping, rc);
2017 kref_put(&wdata->refcount, cifs_writedata_release);
2021 cifs_writev_complete(struct work_struct *work)
2023 struct cifs_writedata *wdata = container_of(work,
2024 struct cifs_writedata, work);
2025 struct inode *inode = wdata->cfile->dentry->d_inode;
2028 if (wdata->result == 0) {
2029 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2030 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2032 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2033 return cifs_writev_requeue(wdata);
2035 for (i = 0; i < wdata->nr_pages; i++) {
2036 struct page *page = wdata->pages[i];
2037 if (wdata->result == -EAGAIN)
2038 __set_page_dirty_nobuffers(page);
2039 else if (wdata->result < 0)
2041 end_page_writeback(page);
2042 page_cache_release(page);
2044 if (wdata->result != -EAGAIN)
2045 mapping_set_error(inode->i_mapping, wdata->result);
2046 kref_put(&wdata->refcount, cifs_writedata_release);
2049 struct cifs_writedata *
2050 cifs_writedata_alloc(unsigned int nr_pages)
2052 struct cifs_writedata *wdata;
2054 /* this would overflow */
2055 if (nr_pages == 0) {
2056 cERROR(1, "%s: called with nr_pages == 0!", __func__);
2060 /* writedata + number of page pointers */
2061 wdata = kzalloc(sizeof(*wdata) +
2062 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
2063 if (wdata != NULL) {
2064 INIT_WORK(&wdata->work, cifs_writev_complete);
2065 kref_init(&wdata->refcount);
2071 * Check the midState and signature on received buffer (if any), and queue the
2072 * workqueue completion task.
2075 cifs_writev_callback(struct mid_q_entry *mid)
2077 struct cifs_writedata *wdata = mid->callback_data;
2078 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2079 unsigned int written;
2080 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2082 switch (mid->midState) {
2083 case MID_RESPONSE_RECEIVED:
2084 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2085 if (wdata->result != 0)
2088 written = le16_to_cpu(smb->CountHigh);
2090 written += le16_to_cpu(smb->Count);
2092 * Mask off high 16 bits when bytes written as returned
2093 * by the server is greater than bytes requested by the
2094 * client. OS/2 servers are known to set incorrect
2097 if (written > wdata->bytes)
2100 if (written < wdata->bytes)
2101 wdata->result = -ENOSPC;
2103 wdata->bytes = written;
2105 case MID_REQUEST_SUBMITTED:
2106 case MID_RETRY_NEEDED:
2107 wdata->result = -EAGAIN;
2110 wdata->result = -EIO;
2114 queue_work(system_nrt_wq, &wdata->work);
2115 DeleteMidQEntry(mid);
2116 cifs_add_credits(tcon->ses->server, 1);
2119 /* cifs_async_writev - send an async write, and set up mid to handle result */
2121 cifs_async_writev(struct cifs_writedata *wdata)
2123 int i, rc = -EACCES;
2124 WRITE_REQ *smb = NULL;
2126 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2127 struct inode *inode = wdata->cfile->dentry->d_inode;
2128 struct kvec *iov = NULL;
2130 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2134 if (wdata->offset >> 32 > 0) {
2135 /* can not handle big offset for old srv */
2140 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2142 goto async_writev_out;
2144 /* 1 iov per page + 1 for header */
2145 iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
2148 goto async_writev_out;
2151 smb->hdr.Pid = cpu_to_le16((__u16)wdata->cfile->pid);
2152 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->cfile->pid >> 16));
2154 smb->AndXCommand = 0xFF; /* none */
2155 smb->Fid = wdata->cfile->netfid;
2156 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2158 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2159 smb->Reserved = 0xFFFFFFFF;
2164 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2166 /* 4 for RFC1001 length + 1 for BCC */
2167 iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2168 iov[0].iov_base = smb;
2170 /* marshal up the pages into iov array */
2172 for (i = 0; i < wdata->nr_pages; i++) {
2173 iov[i + 1].iov_len = min(inode->i_size -
2174 page_offset(wdata->pages[i]),
2175 (loff_t)PAGE_CACHE_SIZE);
2176 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2177 wdata->bytes += iov[i + 1].iov_len;
2180 cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
2182 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2183 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2186 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2187 put_bcc(wdata->bytes + 1, &smb->hdr);
2190 struct smb_com_writex_req *smbw =
2191 (struct smb_com_writex_req *)smb;
2192 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2193 put_bcc(wdata->bytes + 5, &smbw->hdr);
2194 iov[0].iov_len += 4; /* pad bigger by four bytes */
2197 kref_get(&wdata->refcount);
2198 rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
2199 NULL, cifs_writev_callback, wdata, false);
2202 cifs_stats_inc(&tcon->num_writes);
2204 kref_put(&wdata->refcount, cifs_writedata_release);
2206 /* send is done, unmap pages */
2207 for (i = 0; i < wdata->nr_pages; i++)
2208 kunmap(wdata->pages[i]);
2211 cifs_small_buf_release(smb);
2217 CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
2218 unsigned int *nbytes, struct kvec *iov, int n_vec,
2222 WRITE_REQ *pSMB = NULL;
2225 int resp_buf_type = 0;
2226 __u32 pid = io_parms->pid;
2227 __u16 netfid = io_parms->netfid;
2228 __u64 offset = io_parms->offset;
2229 struct cifs_tcon *tcon = io_parms->tcon;
2230 unsigned int count = io_parms->length;
2234 cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
2236 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2240 if ((offset >> 32) > 0) {
2241 /* can not handle big offset for old srv */
2245 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
2249 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2250 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2252 /* tcon and ses pointer are checked in smb_init */
2253 if (tcon->ses->server == NULL)
2254 return -ECONNABORTED;
2256 pSMB->AndXCommand = 0xFF; /* none */
2258 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
2260 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
2261 pSMB->Reserved = 0xFFFFFFFF;
2262 pSMB->WriteMode = 0;
2263 pSMB->Remaining = 0;
2266 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2268 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2269 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
2270 /* header + 1 byte pad */
2271 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
2273 inc_rfc1001_len(pSMB, count + 1);
2274 else /* wct == 12 */
2275 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
2277 pSMB->ByteCount = cpu_to_le16(count + 1);
2278 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2279 struct smb_com_writex_req *pSMBW =
2280 (struct smb_com_writex_req *)pSMB;
2281 pSMBW->ByteCount = cpu_to_le16(count + 5);
2283 iov[0].iov_base = pSMB;
2285 iov[0].iov_len = smb_hdr_len + 4;
2286 else /* wct == 12 pad bigger by four bytes */
2287 iov[0].iov_len = smb_hdr_len + 8;
2290 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
2292 cifs_stats_inc(&tcon->num_writes);
2294 cFYI(1, "Send error Write2 = %d", rc);
2295 } else if (resp_buf_type == 0) {
2296 /* presumably this can not happen, but best to be safe */
2299 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
2300 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2301 *nbytes = (*nbytes) << 16;
2302 *nbytes += le16_to_cpu(pSMBr->Count);
2305 * Mask off high 16 bits when bytes written as returned by the
2306 * server is greater than bytes requested by the client. OS/2
2307 * servers are known to set incorrect CountHigh values.
2309 if (*nbytes > count)
2313 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2314 if (resp_buf_type == CIFS_SMALL_BUFFER)
2315 cifs_small_buf_release(iov[0].iov_base);
2316 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2317 cifs_buf_release(iov[0].iov_base);
2319 /* Note: On -EAGAIN error only caller can retry on handle based calls
2320 since file handle passed in no longer valid */
2325 int cifs_lockv(const int xid, struct cifs_tcon *tcon, const __u16 netfid,
2326 const __u8 lock_type, const __u32 num_unlock,
2327 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2330 LOCK_REQ *pSMB = NULL;
2335 cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
2337 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2342 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2343 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2344 pSMB->LockType = lock_type;
2345 pSMB->AndXCommand = 0xFF; /* none */
2346 pSMB->Fid = netfid; /* netfid stays le */
2348 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2349 inc_rfc1001_len(pSMB, count);
2350 pSMB->ByteCount = cpu_to_le16(count);
2352 iov[0].iov_base = (char *)pSMB;
2353 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2354 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2355 iov[1].iov_base = (char *)buf;
2356 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2358 cifs_stats_inc(&tcon->num_locks);
2359 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2361 cFYI(1, "Send error in cifs_lockv = %d", rc);
2367 CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
2368 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
2369 const __u64 offset, const __u32 numUnlock,
2370 const __u32 numLock, const __u8 lockType,
2371 const bool waitFlag, const __u8 oplock_level)
2374 LOCK_REQ *pSMB = NULL;
2375 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2380 cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
2381 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2386 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
2387 timeout = CIFS_ASYNC_OP; /* no response expected */
2389 } else if (waitFlag) {
2390 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2391 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2396 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2397 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2398 pSMB->LockType = lockType;
2399 pSMB->OplockLevel = oplock_level;
2400 pSMB->AndXCommand = 0xFF; /* none */
2401 pSMB->Fid = smb_file_id; /* netfid stays le */
2403 if ((numLock != 0) || (numUnlock != 0)) {
2404 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
2405 /* BB where to store pid high? */
2406 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2407 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2408 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2409 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2410 count = sizeof(LOCKING_ANDX_RANGE);
2415 inc_rfc1001_len(pSMB, count);
2416 pSMB->ByteCount = cpu_to_le16(count);
2419 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2420 (struct smb_hdr *) pSMB, &bytes_returned);
2421 cifs_small_buf_release(pSMB);
2423 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, timeout);
2424 /* SMB buffer freed by function above */
2426 cifs_stats_inc(&tcon->num_locks);
2428 cFYI(1, "Send error in Lock = %d", rc);
2430 /* Note: On -EAGAIN error only caller can retry on handle based calls
2431 since file handle passed in no longer valid */
2436 CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
2437 const __u16 smb_file_id, const __u32 netpid, const int get_flag,
2438 const __u64 len, struct file_lock *pLockData,
2439 const __u16 lock_type, const bool waitFlag)
2441 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2442 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2443 struct cifs_posix_lock *parm_data;
2446 int bytes_returned = 0;
2447 int resp_buf_type = 0;
2448 __u16 params, param_offset, offset, byte_count, count;
2451 cFYI(1, "Posix Lock");
2453 if (pLockData == NULL)
2456 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2461 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2464 pSMB->MaxSetupCount = 0;
2467 pSMB->Reserved2 = 0;
2468 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2469 offset = param_offset + params;
2471 count = sizeof(struct cifs_posix_lock);
2472 pSMB->MaxParameterCount = cpu_to_le16(2);
2473 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2474 pSMB->SetupCount = 1;
2475 pSMB->Reserved3 = 0;
2477 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2479 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2480 byte_count = 3 /* pad */ + params + count;
2481 pSMB->DataCount = cpu_to_le16(count);
2482 pSMB->ParameterCount = cpu_to_le16(params);
2483 pSMB->TotalDataCount = pSMB->DataCount;
2484 pSMB->TotalParameterCount = pSMB->ParameterCount;
2485 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2486 parm_data = (struct cifs_posix_lock *)
2487 (((char *) &pSMB->hdr.Protocol) + offset);
2489 parm_data->lock_type = cpu_to_le16(lock_type);
2491 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2492 parm_data->lock_flags = cpu_to_le16(1);
2493 pSMB->Timeout = cpu_to_le32(-1);
2497 parm_data->pid = cpu_to_le32(netpid);
2498 parm_data->start = cpu_to_le64(pLockData->fl_start);
2499 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
2501 pSMB->DataOffset = cpu_to_le16(offset);
2502 pSMB->Fid = smb_file_id;
2503 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2504 pSMB->Reserved4 = 0;
2505 inc_rfc1001_len(pSMB, byte_count);
2506 pSMB->ByteCount = cpu_to_le16(byte_count);
2508 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2509 (struct smb_hdr *) pSMBr, &bytes_returned);
2511 iov[0].iov_base = (char *)pSMB;
2512 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2513 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2514 &resp_buf_type, timeout);
2515 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2516 not try to free it twice below on exit */
2517 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
2521 cFYI(1, "Send error in Posix Lock = %d", rc);
2522 } else if (get_flag) {
2523 /* lock structure can be returned on get */
2526 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2528 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2529 rc = -EIO; /* bad smb */
2532 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2533 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2534 if (data_count < sizeof(struct cifs_posix_lock)) {
2538 parm_data = (struct cifs_posix_lock *)
2539 ((char *)&pSMBr->hdr.Protocol + data_offset);
2540 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
2541 pLockData->fl_type = F_UNLCK;
2543 if (parm_data->lock_type ==
2544 __constant_cpu_to_le16(CIFS_RDLCK))
2545 pLockData->fl_type = F_RDLCK;
2546 else if (parm_data->lock_type ==
2547 __constant_cpu_to_le16(CIFS_WRLCK))
2548 pLockData->fl_type = F_WRLCK;
2550 pLockData->fl_start = le64_to_cpu(parm_data->start);
2551 pLockData->fl_end = pLockData->fl_start +
2552 le64_to_cpu(parm_data->length) - 1;
2553 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
2559 cifs_small_buf_release(pSMB);
2561 if (resp_buf_type == CIFS_SMALL_BUFFER)
2562 cifs_small_buf_release(iov[0].iov_base);
2563 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2564 cifs_buf_release(iov[0].iov_base);
2566 /* Note: On -EAGAIN error only caller can retry on handle based calls
2567 since file handle passed in no longer valid */
2574 CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
2577 CLOSE_REQ *pSMB = NULL;
2578 cFYI(1, "In CIFSSMBClose");
2580 /* do not retry on dead session on close */
2581 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2587 pSMB->FileID = (__u16) smb_file_id;
2588 pSMB->LastWriteTime = 0xFFFFFFFF;
2589 pSMB->ByteCount = 0;
2590 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2591 cifs_stats_inc(&tcon->num_closes);
2594 /* EINTR is expected when user ctl-c to kill app */
2595 cERROR(1, "Send error in Close = %d", rc);
2599 /* Since session is dead, file will be closed on server already */
2607 CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
2610 FLUSH_REQ *pSMB = NULL;
2611 cFYI(1, "In CIFSSMBFlush");
2613 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2617 pSMB->FileID = (__u16) smb_file_id;
2618 pSMB->ByteCount = 0;
2619 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2620 cifs_stats_inc(&tcon->num_flushes);
2622 cERROR(1, "Send error in Flush = %d", rc);
2628 CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
2629 const char *fromName, const char *toName,
2630 const struct nls_table *nls_codepage, int remap)
2633 RENAME_REQ *pSMB = NULL;
2634 RENAME_RSP *pSMBr = NULL;
2636 int name_len, name_len2;
2639 cFYI(1, "In CIFSSMBRename");
2641 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2646 pSMB->BufferFormat = 0x04;
2647 pSMB->SearchAttributes =
2648 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2651 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2653 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
2654 PATH_MAX, nls_codepage, remap);
2655 name_len++; /* trailing null */
2657 pSMB->OldFileName[name_len] = 0x04; /* pad */
2658 /* protocol requires ASCII signature byte on Unicode string */
2659 pSMB->OldFileName[name_len + 1] = 0x00;
2661 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2662 toName, PATH_MAX, nls_codepage, remap);
2663 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2664 name_len2 *= 2; /* convert to bytes */
2665 } else { /* BB improve the check for buffer overruns BB */
2666 name_len = strnlen(fromName, PATH_MAX);
2667 name_len++; /* trailing null */
2668 strncpy(pSMB->OldFileName, fromName, name_len);
2669 name_len2 = strnlen(toName, PATH_MAX);
2670 name_len2++; /* trailing null */
2671 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2672 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2673 name_len2++; /* trailing null */
2674 name_len2++; /* signature byte */
2677 count = 1 /* 1st signature byte */ + name_len + name_len2;
2678 inc_rfc1001_len(pSMB, count);
2679 pSMB->ByteCount = cpu_to_le16(count);
2681 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2682 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2683 cifs_stats_inc(&tcon->num_renames);
2685 cFYI(1, "Send error in rename = %d", rc);
2687 cifs_buf_release(pSMB);
2695 int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
2696 int netfid, const char *target_name,
2697 const struct nls_table *nls_codepage, int remap)
2699 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2700 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2701 struct set_file_rename *rename_info;
2703 char dummy_string[30];
2705 int bytes_returned = 0;
2707 __u16 params, param_offset, offset, count, byte_count;
2709 cFYI(1, "Rename to File by handle");
2710 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2716 pSMB->MaxSetupCount = 0;
2720 pSMB->Reserved2 = 0;
2721 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2722 offset = param_offset + params;
2724 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2725 rename_info = (struct set_file_rename *) data_offset;
2726 pSMB->MaxParameterCount = cpu_to_le16(2);
2727 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2728 pSMB->SetupCount = 1;
2729 pSMB->Reserved3 = 0;
2730 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2731 byte_count = 3 /* pad */ + params;
2732 pSMB->ParameterCount = cpu_to_le16(params);
2733 pSMB->TotalParameterCount = pSMB->ParameterCount;
2734 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2735 pSMB->DataOffset = cpu_to_le16(offset);
2736 /* construct random name ".cifs_tmp<inodenum><mid>" */
2737 rename_info->overwrite = cpu_to_le32(1);
2738 rename_info->root_fid = 0;
2739 /* unicode only call */
2740 if (target_name == NULL) {
2741 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2743 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2744 dummy_string, 24, nls_codepage, remap);
2747 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2748 target_name, PATH_MAX, nls_codepage,
2751 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2752 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
2753 byte_count += count;
2754 pSMB->DataCount = cpu_to_le16(count);
2755 pSMB->TotalDataCount = pSMB->DataCount;
2757 pSMB->InformationLevel =
2758 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2759 pSMB->Reserved4 = 0;
2760 inc_rfc1001_len(pSMB, byte_count);
2761 pSMB->ByteCount = cpu_to_le16(byte_count);
2762 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2763 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2764 cifs_stats_inc(&pTcon->num_t2renames);
2766 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
2768 cifs_buf_release(pSMB);
2770 /* Note: On -EAGAIN error only caller can retry on handle based calls
2771 since file handle passed in no longer valid */
2777 CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
2778 const __u16 target_tid, const char *toName, const int flags,
2779 const struct nls_table *nls_codepage, int remap)
2782 COPY_REQ *pSMB = NULL;
2783 COPY_RSP *pSMBr = NULL;
2785 int name_len, name_len2;
2788 cFYI(1, "In CIFSSMBCopy");
2790 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2795 pSMB->BufferFormat = 0x04;
2796 pSMB->Tid2 = target_tid;
2798 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2800 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2801 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2802 fromName, PATH_MAX, nls_codepage,
2804 name_len++; /* trailing null */
2806 pSMB->OldFileName[name_len] = 0x04; /* pad */
2807 /* protocol requires ASCII signature byte on Unicode string */
2808 pSMB->OldFileName[name_len + 1] = 0x00;
2810 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2811 toName, PATH_MAX, nls_codepage, remap);
2812 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2813 name_len2 *= 2; /* convert to bytes */
2814 } else { /* BB improve the check for buffer overruns BB */
2815 name_len = strnlen(fromName, PATH_MAX);
2816 name_len++; /* trailing null */
2817 strncpy(pSMB->OldFileName, fromName, name_len);
2818 name_len2 = strnlen(toName, PATH_MAX);
2819 name_len2++; /* trailing null */
2820 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2821 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2822 name_len2++; /* trailing null */
2823 name_len2++; /* signature byte */
2826 count = 1 /* 1st signature byte */ + name_len + name_len2;
2827 inc_rfc1001_len(pSMB, count);
2828 pSMB->ByteCount = cpu_to_le16(count);
2830 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2831 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2833 cFYI(1, "Send error in copy = %d with %d files copied",
2834 rc, le16_to_cpu(pSMBr->CopyCount));
2836 cifs_buf_release(pSMB);
2845 CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
2846 const char *fromName, const char *toName,
2847 const struct nls_table *nls_codepage)
2849 TRANSACTION2_SPI_REQ *pSMB = NULL;
2850 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2853 int name_len_target;
2855 int bytes_returned = 0;
2856 __u16 params, param_offset, offset, byte_count;
2858 cFYI(1, "In Symlink Unix style");
2860 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2865 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2867 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2868 /* find define for this maxpathcomponent */
2869 PATH_MAX, nls_codepage);
2870 name_len++; /* trailing null */
2873 } else { /* BB improve the check for buffer overruns BB */
2874 name_len = strnlen(fromName, PATH_MAX);
2875 name_len++; /* trailing null */
2876 strncpy(pSMB->FileName, fromName, name_len);
2878 params = 6 + name_len;
2879 pSMB->MaxSetupCount = 0;
2883 pSMB->Reserved2 = 0;
2884 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2885 InformationLevel) - 4;
2886 offset = param_offset + params;
2888 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2889 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2891 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2892 /* find define for this maxpathcomponent */
2894 name_len_target++; /* trailing null */
2895 name_len_target *= 2;
2896 } else { /* BB improve the check for buffer overruns BB */
2897 name_len_target = strnlen(toName, PATH_MAX);
2898 name_len_target++; /* trailing null */
2899 strncpy(data_offset, toName, name_len_target);
2902 pSMB->MaxParameterCount = cpu_to_le16(2);
2903 /* BB find exact max on data count below from sess */
2904 pSMB->MaxDataCount = cpu_to_le16(1000);
2905 pSMB->SetupCount = 1;
2906 pSMB->Reserved3 = 0;
2907 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2908 byte_count = 3 /* pad */ + params + name_len_target;
2909 pSMB->DataCount = cpu_to_le16(name_len_target);
2910 pSMB->ParameterCount = cpu_to_le16(params);
2911 pSMB->TotalDataCount = pSMB->DataCount;
2912 pSMB->TotalParameterCount = pSMB->ParameterCount;
2913 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2914 pSMB->DataOffset = cpu_to_le16(offset);
2915 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2916 pSMB->Reserved4 = 0;
2917 inc_rfc1001_len(pSMB, byte_count);
2918 pSMB->ByteCount = cpu_to_le16(byte_count);
2919 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2920 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2921 cifs_stats_inc(&tcon->num_symlinks);
2923 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
2925 cifs_buf_release(pSMB);
2928 goto createSymLinkRetry;
2934 CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
2935 const char *fromName, const char *toName,
2936 const struct nls_table *nls_codepage, int remap)
2938 TRANSACTION2_SPI_REQ *pSMB = NULL;
2939 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2942 int name_len_target;
2944 int bytes_returned = 0;
2945 __u16 params, param_offset, offset, byte_count;
2947 cFYI(1, "In Create Hard link Unix style");
2948 createHardLinkRetry:
2949 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2954 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2955 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2956 PATH_MAX, nls_codepage, remap);
2957 name_len++; /* trailing null */
2960 } else { /* BB improve the check for buffer overruns BB */
2961 name_len = strnlen(toName, PATH_MAX);
2962 name_len++; /* trailing null */
2963 strncpy(pSMB->FileName, toName, name_len);
2965 params = 6 + name_len;
2966 pSMB->MaxSetupCount = 0;
2970 pSMB->Reserved2 = 0;
2971 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2972 InformationLevel) - 4;
2973 offset = param_offset + params;
2975 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2976 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2978 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2979 PATH_MAX, nls_codepage, remap);
2980 name_len_target++; /* trailing null */
2981 name_len_target *= 2;
2982 } else { /* BB improve the check for buffer overruns BB */
2983 name_len_target = strnlen(fromName, PATH_MAX);
2984 name_len_target++; /* trailing null */
2985 strncpy(data_offset, fromName, name_len_target);
2988 pSMB->MaxParameterCount = cpu_to_le16(2);
2989 /* BB find exact max on data count below from sess*/
2990 pSMB->MaxDataCount = cpu_to_le16(1000);
2991 pSMB->SetupCount = 1;
2992 pSMB->Reserved3 = 0;
2993 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2994 byte_count = 3 /* pad */ + params + name_len_target;
2995 pSMB->ParameterCount = cpu_to_le16(params);
2996 pSMB->TotalParameterCount = pSMB->ParameterCount;
2997 pSMB->DataCount = cpu_to_le16(name_len_target);
2998 pSMB->TotalDataCount = pSMB->DataCount;
2999 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3000 pSMB->DataOffset = cpu_to_le16(offset);
3001 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
3002 pSMB->Reserved4 = 0;
3003 inc_rfc1001_len(pSMB, byte_count);
3004 pSMB->ByteCount = cpu_to_le16(byte_count);
3005 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3006 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3007 cifs_stats_inc(&tcon->num_hardlinks);
3009 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
3011 cifs_buf_release(pSMB);
3013 goto createHardLinkRetry;
3019 CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
3020 const char *fromName, const char *toName,
3021 const struct nls_table *nls_codepage, int remap)
3024 NT_RENAME_REQ *pSMB = NULL;
3025 RENAME_RSP *pSMBr = NULL;
3027 int name_len, name_len2;
3030 cFYI(1, "In CIFSCreateHardLink");
3031 winCreateHardLinkRetry:
3033 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
3038 pSMB->SearchAttributes =
3039 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3041 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
3042 pSMB->ClusterCount = 0;
3044 pSMB->BufferFormat = 0x04;
3046 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3048 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
3049 PATH_MAX, nls_codepage, remap);
3050 name_len++; /* trailing null */
3053 /* protocol specifies ASCII buffer format (0x04) for unicode */
3054 pSMB->OldFileName[name_len] = 0x04;
3055 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
3057 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3058 toName, PATH_MAX, nls_codepage, remap);
3059 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3060 name_len2 *= 2; /* convert to bytes */
3061 } else { /* BB improve the check for buffer overruns BB */
3062 name_len = strnlen(fromName, PATH_MAX);
3063 name_len++; /* trailing null */
3064 strncpy(pSMB->OldFileName, fromName, name_len);
3065 name_len2 = strnlen(toName, PATH_MAX);
3066 name_len2++; /* trailing null */
3067 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3068 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
3069 name_len2++; /* trailing null */
3070 name_len2++; /* signature byte */
3073 count = 1 /* string type byte */ + name_len + name_len2;
3074 inc_rfc1001_len(pSMB, count);
3075 pSMB->ByteCount = cpu_to_le16(count);
3077 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3078 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3079 cifs_stats_inc(&tcon->num_hardlinks);
3081 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
3083 cifs_buf_release(pSMB);
3085 goto winCreateHardLinkRetry;
3091 CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
3092 const unsigned char *searchName, char **symlinkinfo,
3093 const struct nls_table *nls_codepage)
3095 /* SMB_QUERY_FILE_UNIX_LINK */
3096 TRANSACTION2_QPI_REQ *pSMB = NULL;
3097 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3101 __u16 params, byte_count;
3104 cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
3107 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3112 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3114 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3115 PATH_MAX, nls_codepage);
3116 name_len++; /* trailing null */
3118 } else { /* BB improve the check for buffer overruns BB */
3119 name_len = strnlen(searchName, PATH_MAX);
3120 name_len++; /* trailing null */
3121 strncpy(pSMB->FileName, searchName, name_len);
3124 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3125 pSMB->TotalDataCount = 0;
3126 pSMB->MaxParameterCount = cpu_to_le16(2);
3127 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3128 pSMB->MaxSetupCount = 0;
3132 pSMB->Reserved2 = 0;
3133 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3134 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3135 pSMB->DataCount = 0;
3136 pSMB->DataOffset = 0;
3137 pSMB->SetupCount = 1;
3138 pSMB->Reserved3 = 0;
3139 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3140 byte_count = params + 1 /* pad */ ;
3141 pSMB->TotalParameterCount = cpu_to_le16(params);
3142 pSMB->ParameterCount = pSMB->TotalParameterCount;
3143 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3144 pSMB->Reserved4 = 0;
3145 inc_rfc1001_len(pSMB, byte_count);
3146 pSMB->ByteCount = cpu_to_le16(byte_count);
3148 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3149 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3151 cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
3153 /* decode response */
3155 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3156 /* BB also check enough total bytes returned */
3157 if (rc || get_bcc(&pSMBr->hdr) < 2)
3161 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3163 data_start = ((char *) &pSMBr->hdr.Protocol) +
3164 le16_to_cpu(pSMBr->t2.DataOffset);
3166 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3171 /* BB FIXME investigate remapping reserved chars here */
3172 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3173 count, is_unicode, nls_codepage);
3178 cifs_buf_release(pSMB);
3180 goto querySymLinkRetry;
3184 #ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
3186 * Recent Windows versions now create symlinks more frequently
3187 * and they use the "reparse point" mechanism below. We can of course
3188 * do symlinks nicely to Samba and other servers which support the
3189 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3190 * "MF" symlinks optionally, but for recent Windows we really need to
3191 * reenable the code below and fix the cifs_symlink callers to handle this.
3192 * In the interim this code has been moved to its own config option so
3193 * it is not compiled in by default until callers fixed up and more tested.
3196 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
3197 const unsigned char *searchName,
3198 char *symlinkinfo, const int buflen, __u16 fid,
3199 const struct nls_table *nls_codepage)
3203 struct smb_com_transaction_ioctl_req *pSMB;
3204 struct smb_com_transaction_ioctl_rsp *pSMBr;
3206 cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
3207 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3212 pSMB->TotalParameterCount = 0 ;
3213 pSMB->TotalDataCount = 0;
3214 pSMB->MaxParameterCount = cpu_to_le32(2);
3215 /* BB find exact data count max from sess structure BB */
3216 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3217 pSMB->MaxSetupCount = 4;
3219 pSMB->ParameterOffset = 0;
3220 pSMB->DataCount = 0;
3221 pSMB->DataOffset = 0;
3222 pSMB->SetupCount = 4;
3223 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3224 pSMB->ParameterCount = pSMB->TotalParameterCount;
3225 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3226 pSMB->IsFsctl = 1; /* FSCTL */
3227 pSMB->IsRootFlag = 0;
3228 pSMB->Fid = fid; /* file handle always le */
3229 pSMB->ByteCount = 0;
3231 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3232 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3234 cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
3235 } else { /* decode response */
3236 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
3237 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
3238 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3239 /* BB also check enough total bytes returned */
3240 rc = -EIO; /* bad smb */
3243 if (data_count && (data_count < 2048)) {
3244 char *end_of_smb = 2 /* sizeof byte count */ +
3245 get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
3247 struct reparse_data *reparse_buf =
3248 (struct reparse_data *)
3249 ((char *)&pSMBr->hdr.Protocol
3251 if ((char *)reparse_buf >= end_of_smb) {
3255 if ((reparse_buf->LinkNamesBuf +
3256 reparse_buf->TargetNameOffset +
3257 reparse_buf->TargetNameLen) > end_of_smb) {
3258 cFYI(1, "reparse buf beyond SMB");
3263 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3264 cifs_from_ucs2(symlinkinfo, (__le16 *)
3265 (reparse_buf->LinkNamesBuf +
3266 reparse_buf->TargetNameOffset),
3268 reparse_buf->TargetNameLen,
3270 } else { /* ASCII names */
3271 strncpy(symlinkinfo,
3272 reparse_buf->LinkNamesBuf +
3273 reparse_buf->TargetNameOffset,
3274 min_t(const int, buflen,
3275 reparse_buf->TargetNameLen));
3279 cFYI(1, "Invalid return data count on "
3280 "get reparse info ioctl");
3282 symlinkinfo[buflen] = 0; /* just in case so the caller
3283 does not go off the end of the buffer */
3284 cFYI(1, "readlink result - %s", symlinkinfo);
3288 cifs_buf_release(pSMB);
3290 /* Note: On -EAGAIN error only caller can retry on handle based calls
3291 since file handle passed in no longer valid */
3295 #endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
3297 #ifdef CONFIG_CIFS_POSIX
3299 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3300 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3301 struct cifs_posix_ace *cifs_ace)
3303 /* u8 cifs fields do not need le conversion */
3304 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3305 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3306 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
3307 /* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
3312 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3313 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3314 const int acl_type, const int size_of_data_area)
3319 struct cifs_posix_ace *pACE;
3320 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3321 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
3323 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3326 if (acl_type & ACL_TYPE_ACCESS) {
3327 count = le16_to_cpu(cifs_acl->access_entry_count);
3328 pACE = &cifs_acl->ace_array[0];
3329 size = sizeof(struct cifs_posix_acl);
3330 size += sizeof(struct cifs_posix_ace) * count;
3331 /* check if we would go beyond end of SMB */
3332 if (size_of_data_area < size) {
3333 cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
3334 size_of_data_area, size);
3337 } else if (acl_type & ACL_TYPE_DEFAULT) {
3338 count = le16_to_cpu(cifs_acl->access_entry_count);
3339 size = sizeof(struct cifs_posix_acl);
3340 size += sizeof(struct cifs_posix_ace) * count;
3341 /* skip past access ACEs to get to default ACEs */
3342 pACE = &cifs_acl->ace_array[count];
3343 count = le16_to_cpu(cifs_acl->default_entry_count);
3344 size += sizeof(struct cifs_posix_ace) * count;
3345 /* check if we would go beyond end of SMB */
3346 if (size_of_data_area < size)
3353 size = posix_acl_xattr_size(count);
3354 if ((buflen == 0) || (local_acl == NULL)) {
3355 /* used to query ACL EA size */
3356 } else if (size > buflen) {
3358 } else /* buffer big enough */ {
3359 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
3360 for (i = 0; i < count ; i++) {
3361 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3368 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3369 const posix_acl_xattr_entry *local_ace)
3371 __u16 rc = 0; /* 0 = ACL converted ok */
3373 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3374 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
3375 /* BB is there a better way to handle the large uid? */
3376 if (local_ace->e_id == cpu_to_le32(-1)) {
3377 /* Probably no need to le convert -1 on any arch but can not hurt */
3378 cifs_ace->cifs_uid = cpu_to_le64(-1);
3380 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
3381 /*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
3385 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3386 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3387 const int buflen, const int acl_type)
3390 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3391 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
3395 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
3398 count = posix_acl_xattr_count((size_t)buflen);
3399 cFYI(1, "setting acl with %d entries from buf of length %d and "
3401 count, buflen, le32_to_cpu(local_acl->a_version));
3402 if (le32_to_cpu(local_acl->a_version) != 2) {
3403 cFYI(1, "unknown POSIX ACL version %d",
3404 le32_to_cpu(local_acl->a_version));
3407 cifs_acl->version = cpu_to_le16(1);
3408 if (acl_type == ACL_TYPE_ACCESS)
3409 cifs_acl->access_entry_count = cpu_to_le16(count);
3410 else if (acl_type == ACL_TYPE_DEFAULT)
3411 cifs_acl->default_entry_count = cpu_to_le16(count);
3413 cFYI(1, "unknown ACL type %d", acl_type);
3416 for (i = 0; i < count; i++) {
3417 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3418 &local_acl->a_entries[i]);
3420 /* ACE not converted */
3425 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3426 rc += sizeof(struct cifs_posix_acl);
3427 /* BB add check to make sure ACL does not overflow SMB */
3433 CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
3434 const unsigned char *searchName,
3435 char *acl_inf, const int buflen, const int acl_type,
3436 const struct nls_table *nls_codepage, int remap)
3438 /* SMB_QUERY_POSIX_ACL */
3439 TRANSACTION2_QPI_REQ *pSMB = NULL;
3440 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3444 __u16 params, byte_count;
3446 cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
3449 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3454 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3456 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3457 searchName, PATH_MAX, nls_codepage,
3459 name_len++; /* trailing null */
3461 pSMB->FileName[name_len] = 0;
3462 pSMB->FileName[name_len+1] = 0;
3463 } else { /* BB improve the check for buffer overruns BB */
3464 name_len = strnlen(searchName, PATH_MAX);
3465 name_len++; /* trailing null */
3466 strncpy(pSMB->FileName, searchName, name_len);
3469 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3470 pSMB->TotalDataCount = 0;
3471 pSMB->MaxParameterCount = cpu_to_le16(2);
3472 /* BB find exact max data count below from sess structure BB */
3473 pSMB->MaxDataCount = cpu_to_le16(4000);
3474 pSMB->MaxSetupCount = 0;
3478 pSMB->Reserved2 = 0;
3479 pSMB->ParameterOffset = cpu_to_le16(
3480 offsetof(struct smb_com_transaction2_qpi_req,
3481 InformationLevel) - 4);
3482 pSMB->DataCount = 0;
3483 pSMB->DataOffset = 0;
3484 pSMB->SetupCount = 1;
3485 pSMB->Reserved3 = 0;
3486 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3487 byte_count = params + 1 /* pad */ ;
3488 pSMB->TotalParameterCount = cpu_to_le16(params);
3489 pSMB->ParameterCount = pSMB->TotalParameterCount;
3490 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3491 pSMB->Reserved4 = 0;
3492 inc_rfc1001_len(pSMB, byte_count);
3493 pSMB->ByteCount = cpu_to_le16(byte_count);
3495 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3496 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3497 cifs_stats_inc(&tcon->num_acl_get);
3499 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
3501 /* decode response */
3503 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3504 /* BB also check enough total bytes returned */
3505 if (rc || get_bcc(&pSMBr->hdr) < 2)
3506 rc = -EIO; /* bad smb */
3508 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3509 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3510 rc = cifs_copy_posix_acl(acl_inf,
3511 (char *)&pSMBr->hdr.Protocol+data_offset,
3512 buflen, acl_type, count);
3515 cifs_buf_release(pSMB);
3522 CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
3523 const unsigned char *fileName,
3524 const char *local_acl, const int buflen,
3526 const struct nls_table *nls_codepage, int remap)
3528 struct smb_com_transaction2_spi_req *pSMB = NULL;
3529 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3533 int bytes_returned = 0;
3534 __u16 params, byte_count, data_count, param_offset, offset;
3536 cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
3538 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3542 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3544 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3545 PATH_MAX, nls_codepage, remap);
3546 name_len++; /* trailing null */
3548 } else { /* BB improve the check for buffer overruns BB */
3549 name_len = strnlen(fileName, PATH_MAX);
3550 name_len++; /* trailing null */
3551 strncpy(pSMB->FileName, fileName, name_len);
3553 params = 6 + name_len;
3554 pSMB->MaxParameterCount = cpu_to_le16(2);
3555 /* BB find max SMB size from sess */
3556 pSMB->MaxDataCount = cpu_to_le16(1000);
3557 pSMB->MaxSetupCount = 0;
3561 pSMB->Reserved2 = 0;
3562 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3563 InformationLevel) - 4;
3564 offset = param_offset + params;
3565 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3566 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3568 /* convert to on the wire format for POSIX ACL */
3569 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
3571 if (data_count == 0) {
3573 goto setACLerrorExit;
3575 pSMB->DataOffset = cpu_to_le16(offset);
3576 pSMB->SetupCount = 1;
3577 pSMB->Reserved3 = 0;
3578 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3579 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3580 byte_count = 3 /* pad */ + params + data_count;
3581 pSMB->DataCount = cpu_to_le16(data_count);
3582 pSMB->TotalDataCount = pSMB->DataCount;
3583 pSMB->ParameterCount = cpu_to_le16(params);
3584 pSMB->TotalParameterCount = pSMB->ParameterCount;
3585 pSMB->Reserved4 = 0;
3586 inc_rfc1001_len(pSMB, byte_count);
3587 pSMB->ByteCount = cpu_to_le16(byte_count);
3588 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3589 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3591 cFYI(1, "Set POSIX ACL returned %d", rc);
3594 cifs_buf_release(pSMB);
3600 /* BB fix tabs in this function FIXME BB */
3602 CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
3603 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3606 struct smb_t2_qfi_req *pSMB = NULL;
3607 struct smb_t2_qfi_rsp *pSMBr = NULL;
3609 __u16 params, byte_count;
3611 cFYI(1, "In GetExtAttr");
3616 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3621 params = 2 /* level */ + 2 /* fid */;
3622 pSMB->t2.TotalDataCount = 0;
3623 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3624 /* BB find exact max data count below from sess structure BB */
3625 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3626 pSMB->t2.MaxSetupCount = 0;
3627 pSMB->t2.Reserved = 0;
3629 pSMB->t2.Timeout = 0;
3630 pSMB->t2.Reserved2 = 0;
3631 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3633 pSMB->t2.DataCount = 0;
3634 pSMB->t2.DataOffset = 0;
3635 pSMB->t2.SetupCount = 1;
3636 pSMB->t2.Reserved3 = 0;
3637 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3638 byte_count = params + 1 /* pad */ ;
3639 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3640 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3641 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3644 inc_rfc1001_len(pSMB, byte_count);
3645 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3647 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3648 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3650 cFYI(1, "error %d in GetExtAttr", rc);
3652 /* decode response */
3653 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3654 /* BB also check enough total bytes returned */
3655 if (rc || get_bcc(&pSMBr->hdr) < 2)
3656 /* If rc should we check for EOPNOSUPP and
3657 disable the srvino flag? or in caller? */
3658 rc = -EIO; /* bad smb */
3660 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3661 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3662 struct file_chattr_info *pfinfo;
3663 /* BB Do we need a cast or hash here ? */
3665 cFYI(1, "Illegal size ret in GetExtAttr");
3669 pfinfo = (struct file_chattr_info *)
3670 (data_offset + (char *) &pSMBr->hdr.Protocol);
3671 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3672 *pMask = le64_to_cpu(pfinfo->mask);
3676 cifs_buf_release(pSMB);
3678 goto GetExtAttrRetry;
3682 #endif /* CONFIG_POSIX */
3684 #ifdef CONFIG_CIFS_ACL
3686 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3687 * all NT TRANSACTS that we init here have total parm and data under about 400
3688 * bytes (to fit in small cifs buffer size), which is the case so far, it
3689 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3690 * returned setup area) and MaxParameterCount (returned parms size) must be set
3694 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3695 const int parm_len, struct cifs_tcon *tcon,
3700 struct smb_com_ntransact_req *pSMB;
3702 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3706 *ret_buf = (void *)pSMB;
3708 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3709 pSMB->TotalDataCount = 0;
3710 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3711 pSMB->ParameterCount = pSMB->TotalParameterCount;
3712 pSMB->DataCount = pSMB->TotalDataCount;
3713 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3714 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3715 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3716 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3717 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3718 pSMB->SubCommand = cpu_to_le16(sub_command);
3723 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3724 __u32 *pparmlen, __u32 *pdatalen)
3727 __u32 data_count, data_offset, parm_count, parm_offset;
3728 struct smb_com_ntransact_rsp *pSMBr;
3737 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3739 bcc = get_bcc(&pSMBr->hdr);
3740 end_of_smb = 2 /* sizeof byte count */ + bcc +
3741 (char *)&pSMBr->ByteCount;
3743 data_offset = le32_to_cpu(pSMBr->DataOffset);
3744 data_count = le32_to_cpu(pSMBr->DataCount);
3745 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3746 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3748 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3749 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3751 /* should we also check that parm and data areas do not overlap? */
3752 if (*ppparm > end_of_smb) {
3753 cFYI(1, "parms start after end of smb");
3755 } else if (parm_count + *ppparm > end_of_smb) {
3756 cFYI(1, "parm end after end of smb");
3758 } else if (*ppdata > end_of_smb) {
3759 cFYI(1, "data starts after end of smb");
3761 } else if (data_count + *ppdata > end_of_smb) {
3762 cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
3763 *ppdata, data_count, (data_count + *ppdata),
3766 } else if (parm_count + data_count > bcc) {
3767 cFYI(1, "parm count and data count larger than SMB");
3770 *pdatalen = data_count;
3771 *pparmlen = parm_count;
3775 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3777 CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
3778 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3782 QUERY_SEC_DESC_REQ *pSMB;
3785 cFYI(1, "GetCifsACL");
3790 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3791 8 /* parm len */, tcon, (void **) &pSMB);
3795 pSMB->MaxParameterCount = cpu_to_le32(4);
3796 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3797 pSMB->MaxSetupCount = 0;
3798 pSMB->Fid = fid; /* file handle always le */
3799 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3801 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3802 inc_rfc1001_len(pSMB, 11);
3803 iov[0].iov_base = (char *)pSMB;
3804 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3806 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3808 cifs_stats_inc(&tcon->num_acl_get);
3810 cFYI(1, "Send error in QuerySecDesc = %d", rc);
3811 } else { /* decode response */
3815 struct smb_com_ntransact_rsp *pSMBr;
3818 /* validate_nttransact */
3819 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3820 &pdata, &parm_len, pbuflen);
3823 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3825 cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
3827 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3828 rc = -EIO; /* bad smb */
3833 /* BB check that data area is minimum length and as big as acl_len */
3835 acl_len = le32_to_cpu(*parm);
3836 if (acl_len != *pbuflen) {
3837 cERROR(1, "acl length %d does not match %d",
3839 if (*pbuflen > acl_len)
3843 /* check if buffer is big enough for the acl
3844 header followed by the smallest SID */
3845 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3846 (*pbuflen >= 64 * 1024)) {
3847 cERROR(1, "bad acl length %d", *pbuflen);
3851 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3852 if (*acl_inf == NULL) {
3856 memcpy(*acl_inf, pdata, *pbuflen);
3860 if (buf_type == CIFS_SMALL_BUFFER)
3861 cifs_small_buf_release(iov[0].iov_base);
3862 else if (buf_type == CIFS_LARGE_BUFFER)
3863 cifs_buf_release(iov[0].iov_base);
3864 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3869 CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
3870 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3872 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3874 int bytes_returned = 0;
3875 SET_SEC_DESC_REQ *pSMB = NULL;
3876 NTRANSACT_RSP *pSMBr = NULL;
3879 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3884 pSMB->MaxSetupCount = 0;
3888 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3889 data_count = acllen;
3890 data_offset = param_offset + param_count;
3891 byte_count = 3 /* pad */ + param_count;
3893 pSMB->DataCount = cpu_to_le32(data_count);
3894 pSMB->TotalDataCount = pSMB->DataCount;
3895 pSMB->MaxParameterCount = cpu_to_le32(4);
3896 pSMB->MaxDataCount = cpu_to_le32(16384);
3897 pSMB->ParameterCount = cpu_to_le32(param_count);
3898 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3899 pSMB->TotalParameterCount = pSMB->ParameterCount;
3900 pSMB->DataOffset = cpu_to_le32(data_offset);
3901 pSMB->SetupCount = 0;
3902 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3903 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3905 pSMB->Fid = fid; /* file handle always le */
3906 pSMB->Reserved2 = 0;
3907 pSMB->AclFlags = cpu_to_le32(aclflag);
3909 if (pntsd && acllen) {
3910 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3913 inc_rfc1001_len(pSMB, byte_count + data_count);
3915 inc_rfc1001_len(pSMB, byte_count);
3917 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3918 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3920 cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
3922 cFYI(1, "Set CIFS ACL returned %d", rc);
3923 cifs_buf_release(pSMB);
3926 goto setCifsAclRetry;
3931 #endif /* CONFIG_CIFS_ACL */
3933 /* Legacy Query Path Information call for lookup to old servers such
3935 int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
3936 const unsigned char *searchName,
3937 FILE_ALL_INFO *pFinfo,
3938 const struct nls_table *nls_codepage, int remap)
3940 QUERY_INFORMATION_REQ *pSMB;
3941 QUERY_INFORMATION_RSP *pSMBr;
3946 cFYI(1, "In SMBQPath path %s", searchName);
3948 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3953 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3955 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3956 searchName, PATH_MAX, nls_codepage,
3958 name_len++; /* trailing null */
3961 name_len = strnlen(searchName, PATH_MAX);
3962 name_len++; /* trailing null */
3963 strncpy(pSMB->FileName, searchName, name_len);
3965 pSMB->BufferFormat = 0x04;
3966 name_len++; /* account for buffer type byte */
3967 inc_rfc1001_len(pSMB, (__u16)name_len);
3968 pSMB->ByteCount = cpu_to_le16(name_len);
3970 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3971 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3973 cFYI(1, "Send error in QueryInfo = %d", rc);
3974 } else if (pFinfo) {
3976 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3978 /* decode response */
3979 /* BB FIXME - add time zone adjustment BB */
3980 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
3983 /* decode time fields */
3984 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3985 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3986 pFinfo->LastAccessTime = 0;
3987 pFinfo->AllocationSize =
3988 cpu_to_le64(le32_to_cpu(pSMBr->size));
3989 pFinfo->EndOfFile = pFinfo->AllocationSize;
3990 pFinfo->Attributes =
3991 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3993 rc = -EIO; /* bad buffer passed in */
3995 cifs_buf_release(pSMB);
4004 CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
4005 u16 netfid, FILE_ALL_INFO *pFindData)
4007 struct smb_t2_qfi_req *pSMB = NULL;
4008 struct smb_t2_qfi_rsp *pSMBr = NULL;
4011 __u16 params, byte_count;
4014 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4019 params = 2 /* level */ + 2 /* fid */;
4020 pSMB->t2.TotalDataCount = 0;
4021 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4022 /* BB find exact max data count below from sess structure BB */
4023 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4024 pSMB->t2.MaxSetupCount = 0;
4025 pSMB->t2.Reserved = 0;
4027 pSMB->t2.Timeout = 0;
4028 pSMB->t2.Reserved2 = 0;
4029 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4031 pSMB->t2.DataCount = 0;
4032 pSMB->t2.DataOffset = 0;
4033 pSMB->t2.SetupCount = 1;
4034 pSMB->t2.Reserved3 = 0;
4035 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4036 byte_count = params + 1 /* pad */ ;
4037 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4038 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4039 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4042 inc_rfc1001_len(pSMB, byte_count);
4044 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4045 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4047 cFYI(1, "Send error in QPathInfo = %d", rc);
4048 } else { /* decode response */
4049 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4051 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4053 else if (get_bcc(&pSMBr->hdr) < 40)
4054 rc = -EIO; /* bad smb */
4055 else if (pFindData) {
4056 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4057 memcpy((char *) pFindData,
4058 (char *) &pSMBr->hdr.Protocol +
4059 data_offset, sizeof(FILE_ALL_INFO));
4063 cifs_buf_release(pSMB);
4065 goto QFileInfoRetry;
4071 CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
4072 const unsigned char *searchName,
4073 FILE_ALL_INFO *pFindData,
4074 int legacy /* old style infolevel */,
4075 const struct nls_table *nls_codepage, int remap)
4077 /* level 263 SMB_QUERY_FILE_ALL_INFO */
4078 TRANSACTION2_QPI_REQ *pSMB = NULL;
4079 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4083 __u16 params, byte_count;
4085 /* cFYI(1, "In QPathInfo path %s", searchName); */
4087 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4092 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4094 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4095 PATH_MAX, nls_codepage, remap);
4096 name_len++; /* trailing null */
4098 } else { /* BB improve the check for buffer overruns BB */
4099 name_len = strnlen(searchName, PATH_MAX);
4100 name_len++; /* trailing null */
4101 strncpy(pSMB->FileName, searchName, name_len);
4104 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4105 pSMB->TotalDataCount = 0;
4106 pSMB->MaxParameterCount = cpu_to_le16(2);
4107 /* BB find exact max SMB PDU from sess structure BB */
4108 pSMB->MaxDataCount = cpu_to_le16(4000);
4109 pSMB->MaxSetupCount = 0;
4113 pSMB->Reserved2 = 0;
4114 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4115 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4116 pSMB->DataCount = 0;
4117 pSMB->DataOffset = 0;
4118 pSMB->SetupCount = 1;
4119 pSMB->Reserved3 = 0;
4120 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4121 byte_count = params + 1 /* pad */ ;
4122 pSMB->TotalParameterCount = cpu_to_le16(params);
4123 pSMB->ParameterCount = pSMB->TotalParameterCount;
4125 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4127 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4128 pSMB->Reserved4 = 0;
4129 inc_rfc1001_len(pSMB, byte_count);
4130 pSMB->ByteCount = cpu_to_le16(byte_count);
4132 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4133 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4135 cFYI(1, "Send error in QPathInfo = %d", rc);
4136 } else { /* decode response */
4137 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4139 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4141 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
4142 rc = -EIO; /* bad smb */
4143 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
4144 rc = -EIO; /* 24 or 26 expected but we do not read
4146 else if (pFindData) {
4148 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4150 /* On legacy responses we do not read the last field,
4151 EAsize, fortunately since it varies by subdialect and
4152 also note it differs on Set vs. Get, ie two bytes or 4
4153 bytes depending but we don't care here */
4155 size = sizeof(FILE_INFO_STANDARD);
4157 size = sizeof(FILE_ALL_INFO);
4158 memcpy((char *) pFindData,
4159 (char *) &pSMBr->hdr.Protocol +
4164 cifs_buf_release(pSMB);
4166 goto QPathInfoRetry;
4172 CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
4173 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4175 struct smb_t2_qfi_req *pSMB = NULL;
4176 struct smb_t2_qfi_rsp *pSMBr = NULL;
4179 __u16 params, byte_count;
4182 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4187 params = 2 /* level */ + 2 /* fid */;
4188 pSMB->t2.TotalDataCount = 0;
4189 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4190 /* BB find exact max data count below from sess structure BB */
4191 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4192 pSMB->t2.MaxSetupCount = 0;
4193 pSMB->t2.Reserved = 0;
4195 pSMB->t2.Timeout = 0;
4196 pSMB->t2.Reserved2 = 0;
4197 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4199 pSMB->t2.DataCount = 0;
4200 pSMB->t2.DataOffset = 0;
4201 pSMB->t2.SetupCount = 1;
4202 pSMB->t2.Reserved3 = 0;
4203 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4204 byte_count = params + 1 /* pad */ ;
4205 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4206 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4207 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4210 inc_rfc1001_len(pSMB, byte_count);
4212 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4213 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4215 cFYI(1, "Send error in QPathInfo = %d", rc);
4216 } else { /* decode response */
4217 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4219 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4220 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
4221 "Unix Extensions can be disabled on mount "
4222 "by specifying the nosfu mount option.");
4223 rc = -EIO; /* bad smb */
4225 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4226 memcpy((char *) pFindData,
4227 (char *) &pSMBr->hdr.Protocol +
4229 sizeof(FILE_UNIX_BASIC_INFO));
4233 cifs_buf_release(pSMB);
4235 goto UnixQFileInfoRetry;
4241 CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
4242 const unsigned char *searchName,
4243 FILE_UNIX_BASIC_INFO *pFindData,
4244 const struct nls_table *nls_codepage, int remap)
4246 /* SMB_QUERY_FILE_UNIX_BASIC */
4247 TRANSACTION2_QPI_REQ *pSMB = NULL;
4248 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4250 int bytes_returned = 0;
4252 __u16 params, byte_count;
4254 cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
4256 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4261 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4263 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4264 PATH_MAX, nls_codepage, remap);
4265 name_len++; /* trailing null */
4267 } else { /* BB improve the check for buffer overruns BB */
4268 name_len = strnlen(searchName, PATH_MAX);
4269 name_len++; /* trailing null */
4270 strncpy(pSMB->FileName, searchName, name_len);
4273 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4274 pSMB->TotalDataCount = 0;
4275 pSMB->MaxParameterCount = cpu_to_le16(2);
4276 /* BB find exact max SMB PDU from sess structure BB */
4277 pSMB->MaxDataCount = cpu_to_le16(4000);
4278 pSMB->MaxSetupCount = 0;
4282 pSMB->Reserved2 = 0;
4283 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4284 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4285 pSMB->DataCount = 0;
4286 pSMB->DataOffset = 0;
4287 pSMB->SetupCount = 1;
4288 pSMB->Reserved3 = 0;
4289 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4290 byte_count = params + 1 /* pad */ ;
4291 pSMB->TotalParameterCount = cpu_to_le16(params);
4292 pSMB->ParameterCount = pSMB->TotalParameterCount;
4293 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4294 pSMB->Reserved4 = 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);
4301 cFYI(1, "Send error in QPathInfo = %d", rc);
4302 } else { /* decode response */
4303 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4305 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4306 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
4307 "Unix Extensions can be disabled on mount "
4308 "by specifying the nosfu mount option.");
4309 rc = -EIO; /* bad smb */
4311 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4312 memcpy((char *) pFindData,
4313 (char *) &pSMBr->hdr.Protocol +
4315 sizeof(FILE_UNIX_BASIC_INFO));
4318 cifs_buf_release(pSMB);
4320 goto UnixQPathInfoRetry;
4325 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4327 CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
4328 const char *searchName,
4329 const struct nls_table *nls_codepage,
4331 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
4333 /* level 257 SMB_ */
4334 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4335 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
4336 T2_FFIRST_RSP_PARMS *parms;
4338 int bytes_returned = 0;
4340 __u16 params, byte_count;
4342 cFYI(1, "In FindFirst for %s", searchName);
4345 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4350 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4352 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4353 PATH_MAX, nls_codepage, remap);
4354 /* We can not add the asterik earlier in case
4355 it got remapped to 0xF03A as if it were part of the
4356 directory name instead of a wildcard */
4358 pSMB->FileName[name_len] = dirsep;
4359 pSMB->FileName[name_len+1] = 0;
4360 pSMB->FileName[name_len+2] = '*';
4361 pSMB->FileName[name_len+3] = 0;
4362 name_len += 4; /* now the trailing null */
4363 pSMB->FileName[name_len] = 0; /* null terminate just in case */
4364 pSMB->FileName[name_len+1] = 0;
4366 } else { /* BB add check for overrun of SMB buf BB */
4367 name_len = strnlen(searchName, PATH_MAX);
4368 /* BB fix here and in unicode clause above ie
4369 if (name_len > buffersize-header)
4370 free buffer exit; BB */
4371 strncpy(pSMB->FileName, searchName, name_len);
4372 pSMB->FileName[name_len] = dirsep;
4373 pSMB->FileName[name_len+1] = '*';
4374 pSMB->FileName[name_len+2] = 0;
4378 params = 12 + name_len /* includes null */ ;
4379 pSMB->TotalDataCount = 0; /* no EAs */
4380 pSMB->MaxParameterCount = cpu_to_le16(10);
4381 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4382 pSMB->MaxSetupCount = 0;
4386 pSMB->Reserved2 = 0;
4387 byte_count = params + 1 /* pad */ ;
4388 pSMB->TotalParameterCount = cpu_to_le16(params);
4389 pSMB->ParameterCount = pSMB->TotalParameterCount;
4390 pSMB->ParameterOffset = cpu_to_le16(
4391 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4393 pSMB->DataCount = 0;
4394 pSMB->DataOffset = 0;
4395 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4396 pSMB->Reserved3 = 0;
4397 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4398 pSMB->SearchAttributes =
4399 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4401 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4402 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
4403 CIFS_SEARCH_RETURN_RESUME);
4404 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4406 /* BB what should we set StorageType to? Does it matter? BB */
4407 pSMB->SearchStorageType = 0;
4408 inc_rfc1001_len(pSMB, byte_count);
4409 pSMB->ByteCount = cpu_to_le16(byte_count);
4411 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4412 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4413 cifs_stats_inc(&tcon->num_ffirst);
4415 if (rc) {/* BB add logic to retry regular search if Unix search
4416 rejected unexpectedly by server */
4417 /* BB Add code to handle unsupported level rc */
4418 cFYI(1, "Error in FindFirst = %d", rc);
4420 cifs_buf_release(pSMB);
4422 /* BB eventually could optimize out free and realloc of buf */
4425 goto findFirstRetry;
4426 } else { /* decode response */
4427 /* BB remember to free buffer if error BB */
4428 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4432 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4433 psrch_inf->unicode = true;
4435 psrch_inf->unicode = false;
4437 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4438 psrch_inf->smallBuf = 0;
4439 psrch_inf->srch_entries_start =
4440 (char *) &pSMBr->hdr.Protocol +
4441 le16_to_cpu(pSMBr->t2.DataOffset);
4442 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4443 le16_to_cpu(pSMBr->t2.ParameterOffset));
4445 if (parms->EndofSearch)
4446 psrch_inf->endOfSearch = true;
4448 psrch_inf->endOfSearch = false;
4450 psrch_inf->entries_in_buffer =
4451 le16_to_cpu(parms->SearchCount);
4452 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4453 psrch_inf->entries_in_buffer;
4454 lnoff = le16_to_cpu(parms->LastNameOffset);
4455 if (CIFSMaxBufSize < lnoff) {
4456 cERROR(1, "ignoring corrupt resume name");
4457 psrch_inf->last_entry = NULL;
4461 psrch_inf->last_entry = psrch_inf->srch_entries_start +
4464 *pnetfid = parms->SearchHandle;
4466 cifs_buf_release(pSMB);
4473 int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
4474 __u16 searchHandle, struct cifs_search_info *psrch_inf)
4476 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4477 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4478 T2_FNEXT_RSP_PARMS *parms;
4479 char *response_data;
4482 unsigned int name_len;
4483 __u16 params, byte_count;
4485 cFYI(1, "In FindNext");
4487 if (psrch_inf->endOfSearch)
4490 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4495 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4497 pSMB->TotalDataCount = 0; /* no EAs */
4498 pSMB->MaxParameterCount = cpu_to_le16(8);
4499 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4500 pSMB->MaxSetupCount = 0;
4504 pSMB->Reserved2 = 0;
4505 pSMB->ParameterOffset = cpu_to_le16(
4506 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4507 pSMB->DataCount = 0;
4508 pSMB->DataOffset = 0;
4509 pSMB->SetupCount = 1;
4510 pSMB->Reserved3 = 0;
4511 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4512 pSMB->SearchHandle = searchHandle; /* always kept as le */
4514 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4515 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4516 pSMB->ResumeKey = psrch_inf->resume_key;
4518 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
4520 name_len = psrch_inf->resume_name_len;
4522 if (name_len < PATH_MAX) {
4523 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4524 byte_count += name_len;
4525 /* 14 byte parm len above enough for 2 byte null terminator */
4526 pSMB->ResumeFileName[name_len] = 0;
4527 pSMB->ResumeFileName[name_len+1] = 0;
4530 goto FNext2_err_exit;
4532 byte_count = params + 1 /* pad */ ;
4533 pSMB->TotalParameterCount = cpu_to_le16(params);
4534 pSMB->ParameterCount = pSMB->TotalParameterCount;
4535 inc_rfc1001_len(pSMB, byte_count);
4536 pSMB->ByteCount = cpu_to_le16(byte_count);
4538 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4539 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4540 cifs_stats_inc(&tcon->num_fnext);
4543 psrch_inf->endOfSearch = true;
4544 cifs_buf_release(pSMB);
4545 rc = 0; /* search probably was closed at end of search*/
4547 cFYI(1, "FindNext returned = %d", rc);
4548 } else { /* decode response */
4549 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4554 /* BB fixme add lock for file (srch_info) struct here */
4555 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4556 psrch_inf->unicode = true;
4558 psrch_inf->unicode = false;
4559 response_data = (char *) &pSMBr->hdr.Protocol +
4560 le16_to_cpu(pSMBr->t2.ParameterOffset);
4561 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4562 response_data = (char *)&pSMBr->hdr.Protocol +
4563 le16_to_cpu(pSMBr->t2.DataOffset);
4564 if (psrch_inf->smallBuf)
4565 cifs_small_buf_release(
4566 psrch_inf->ntwrk_buf_start);
4568 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4569 psrch_inf->srch_entries_start = response_data;
4570 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4571 psrch_inf->smallBuf = 0;
4572 if (parms->EndofSearch)
4573 psrch_inf->endOfSearch = true;
4575 psrch_inf->endOfSearch = false;
4576 psrch_inf->entries_in_buffer =
4577 le16_to_cpu(parms->SearchCount);
4578 psrch_inf->index_of_last_entry +=
4579 psrch_inf->entries_in_buffer;
4580 lnoff = le16_to_cpu(parms->LastNameOffset);
4581 if (CIFSMaxBufSize < lnoff) {
4582 cERROR(1, "ignoring corrupt resume name");
4583 psrch_inf->last_entry = NULL;
4586 psrch_inf->last_entry =
4587 psrch_inf->srch_entries_start + lnoff;
4589 /* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
4590 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4592 /* BB fixme add unlock here */
4597 /* BB On error, should we leave previous search buf (and count and
4598 last entry fields) intact or free the previous one? */
4600 /* Note: On -EAGAIN error only caller can retry on handle based calls
4601 since file handle passed in no longer valid */
4604 cifs_buf_release(pSMB);
4609 CIFSFindClose(const int xid, struct cifs_tcon *tcon,
4610 const __u16 searchHandle)
4613 FINDCLOSE_REQ *pSMB = NULL;
4615 cFYI(1, "In CIFSSMBFindClose");
4616 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4618 /* no sense returning error if session restarted
4619 as file handle has been closed */
4625 pSMB->FileID = searchHandle;
4626 pSMB->ByteCount = 0;
4627 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4629 cERROR(1, "Send error in FindClose = %d", rc);
4631 cifs_stats_inc(&tcon->num_fclose);
4633 /* Since session is dead, search handle closed on server already */
4641 CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
4642 const unsigned char *searchName,
4643 __u64 *inode_number,
4644 const struct nls_table *nls_codepage, int remap)
4647 TRANSACTION2_QPI_REQ *pSMB = NULL;
4648 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4649 int name_len, bytes_returned;
4650 __u16 params, byte_count;
4652 cFYI(1, "In GetSrvInodeNum for %s", searchName);
4656 GetInodeNumberRetry:
4657 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4662 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4664 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4665 searchName, PATH_MAX, nls_codepage,
4667 name_len++; /* trailing null */
4669 } else { /* BB improve the check for buffer overruns BB */
4670 name_len = strnlen(searchName, PATH_MAX);
4671 name_len++; /* trailing null */
4672 strncpy(pSMB->FileName, searchName, name_len);
4675 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4676 pSMB->TotalDataCount = 0;
4677 pSMB->MaxParameterCount = cpu_to_le16(2);
4678 /* BB find exact max data count below from sess structure BB */
4679 pSMB->MaxDataCount = cpu_to_le16(4000);
4680 pSMB->MaxSetupCount = 0;
4684 pSMB->Reserved2 = 0;
4685 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4686 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4687 pSMB->DataCount = 0;
4688 pSMB->DataOffset = 0;
4689 pSMB->SetupCount = 1;
4690 pSMB->Reserved3 = 0;
4691 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4692 byte_count = params + 1 /* pad */ ;
4693 pSMB->TotalParameterCount = cpu_to_le16(params);
4694 pSMB->ParameterCount = pSMB->TotalParameterCount;
4695 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4696 pSMB->Reserved4 = 0;
4697 inc_rfc1001_len(pSMB, byte_count);
4698 pSMB->ByteCount = cpu_to_le16(byte_count);
4700 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4701 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4703 cFYI(1, "error %d in QueryInternalInfo", rc);
4705 /* decode response */
4706 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4707 /* BB also check enough total bytes returned */
4708 if (rc || get_bcc(&pSMBr->hdr) < 2)
4709 /* If rc should we check for EOPNOSUPP and
4710 disable the srvino flag? or in caller? */
4711 rc = -EIO; /* bad smb */
4713 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4714 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4715 struct file_internal_info *pfinfo;
4716 /* BB Do we need a cast or hash here ? */
4718 cFYI(1, "Illegal size ret in QryIntrnlInf");
4720 goto GetInodeNumOut;
4722 pfinfo = (struct file_internal_info *)
4723 (data_offset + (char *) &pSMBr->hdr.Protocol);
4724 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4728 cifs_buf_release(pSMB);
4730 goto GetInodeNumberRetry;
4734 /* parses DFS refferal V3 structure
4735 * caller is responsible for freeing target_nodes
4738 * on failure - errno
4741 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
4742 unsigned int *num_of_nodes,
4743 struct dfs_info3_param **target_nodes,
4744 const struct nls_table *nls_codepage, int remap,
4745 const char *searchName)
4750 struct dfs_referral_level_3 *ref;
4752 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4756 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4758 if (*num_of_nodes < 1) {
4759 cERROR(1, "num_referrals: must be at least > 0,"
4760 "but we get num_referrals = %d\n", *num_of_nodes);
4762 goto parse_DFS_referrals_exit;
4765 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
4766 if (ref->VersionNumber != cpu_to_le16(3)) {
4767 cERROR(1, "Referrals of V%d version are not supported,"
4768 "should be V3", le16_to_cpu(ref->VersionNumber));
4770 goto parse_DFS_referrals_exit;
4773 /* get the upper boundary of the resp buffer */
4774 data_end = (char *)(&(pSMBr->PathConsumed)) +
4775 le16_to_cpu(pSMBr->t2.DataCount);
4777 cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
4779 le32_to_cpu(pSMBr->DFSFlags));
4781 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
4782 *num_of_nodes, GFP_KERNEL);
4783 if (*target_nodes == NULL) {
4784 cERROR(1, "Failed to allocate buffer for target_nodes\n");
4786 goto parse_DFS_referrals_exit;
4789 /* collect necessary data from referrals */
4790 for (i = 0; i < *num_of_nodes; i++) {
4793 struct dfs_info3_param *node = (*target_nodes)+i;
4795 node->flags = le32_to_cpu(pSMBr->DFSFlags);
4797 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4801 goto parse_DFS_referrals_exit;
4803 cifsConvertToUTF16((__le16 *) tmp, searchName,
4804 PATH_MAX, nls_codepage, remap);
4805 node->path_consumed = cifs_utf16_bytes(tmp,
4806 le16_to_cpu(pSMBr->PathConsumed),
4810 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4812 node->server_type = le16_to_cpu(ref->ServerType);
4813 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4816 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4817 max_len = data_end - temp;
4818 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4819 is_unicode, nls_codepage);
4820 if (!node->path_name) {
4822 goto parse_DFS_referrals_exit;
4825 /* copy link target UNC */
4826 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4827 max_len = data_end - temp;
4828 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4829 is_unicode, nls_codepage);
4830 if (!node->node_name)
4834 parse_DFS_referrals_exit:
4836 free_dfs_info_array(*target_nodes, *num_of_nodes);
4837 *target_nodes = NULL;
4844 CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
4845 const unsigned char *searchName,
4846 struct dfs_info3_param **target_nodes,
4847 unsigned int *num_of_nodes,
4848 const struct nls_table *nls_codepage, int remap)
4850 /* TRANS2_GET_DFS_REFERRAL */
4851 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4852 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4856 __u16 params, byte_count;
4858 *target_nodes = NULL;
4860 cFYI(1, "In GetDFSRefer the path %s", searchName);
4864 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4869 /* server pointer checked in called function,
4870 but should never be null here anyway */
4871 pSMB->hdr.Mid = GetNextMid(ses->server);
4872 pSMB->hdr.Tid = ses->ipc_tid;
4873 pSMB->hdr.Uid = ses->Suid;
4874 if (ses->capabilities & CAP_STATUS32)
4875 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4876 if (ses->capabilities & CAP_DFS)
4877 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4879 if (ses->capabilities & CAP_UNICODE) {
4880 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4882 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4883 searchName, PATH_MAX, nls_codepage,
4885 name_len++; /* trailing null */
4887 } else { /* BB improve the check for buffer overruns BB */
4888 name_len = strnlen(searchName, PATH_MAX);
4889 name_len++; /* trailing null */
4890 strncpy(pSMB->RequestFileName, searchName, name_len);
4894 if (ses->server->sec_mode &
4895 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4896 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4899 pSMB->hdr.Uid = ses->Suid;
4901 params = 2 /* level */ + name_len /*includes null */ ;
4902 pSMB->TotalDataCount = 0;
4903 pSMB->DataCount = 0;
4904 pSMB->DataOffset = 0;
4905 pSMB->MaxParameterCount = 0;
4906 /* BB find exact max SMB PDU from sess structure BB */
4907 pSMB->MaxDataCount = cpu_to_le16(4000);
4908 pSMB->MaxSetupCount = 0;
4912 pSMB->Reserved2 = 0;
4913 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4914 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4915 pSMB->SetupCount = 1;
4916 pSMB->Reserved3 = 0;
4917 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4918 byte_count = params + 3 /* pad */ ;
4919 pSMB->ParameterCount = cpu_to_le16(params);
4920 pSMB->TotalParameterCount = pSMB->ParameterCount;
4921 pSMB->MaxReferralLevel = cpu_to_le16(3);
4922 inc_rfc1001_len(pSMB, byte_count);
4923 pSMB->ByteCount = cpu_to_le16(byte_count);
4925 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4926 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4928 cFYI(1, "Send error in GetDFSRefer = %d", rc);
4931 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4933 /* BB Also check if enough total bytes returned? */
4934 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4935 rc = -EIO; /* bad smb */
4939 cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
4940 get_bcc(&pSMBr->hdr),
4941 le16_to_cpu(pSMBr->t2.DataOffset));
4943 /* parse returned result into more usable form */
4944 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
4945 target_nodes, nls_codepage, remap,
4949 cifs_buf_release(pSMB);
4957 /* Query File System Info such as free space to old servers such as Win 9x */
4959 SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
4961 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4962 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4963 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4964 FILE_SYSTEM_ALLOC_INFO *response_data;
4966 int bytes_returned = 0;
4967 __u16 params, byte_count;
4969 cFYI(1, "OldQFSInfo");
4971 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4976 params = 2; /* level */
4977 pSMB->TotalDataCount = 0;
4978 pSMB->MaxParameterCount = cpu_to_le16(2);
4979 pSMB->MaxDataCount = cpu_to_le16(1000);
4980 pSMB->MaxSetupCount = 0;
4984 pSMB->Reserved2 = 0;
4985 byte_count = params + 1 /* pad */ ;
4986 pSMB->TotalParameterCount = cpu_to_le16(params);
4987 pSMB->ParameterCount = pSMB->TotalParameterCount;
4988 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4989 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4990 pSMB->DataCount = 0;
4991 pSMB->DataOffset = 0;
4992 pSMB->SetupCount = 1;
4993 pSMB->Reserved3 = 0;
4994 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4995 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4996 inc_rfc1001_len(pSMB, byte_count);
4997 pSMB->ByteCount = cpu_to_le16(byte_count);
4999 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5000 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5002 cFYI(1, "Send error in QFSInfo = %d", rc);
5003 } else { /* decode response */
5004 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5006 if (rc || get_bcc(&pSMBr->hdr) < 18)
5007 rc = -EIO; /* bad smb */
5009 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5010 cFYI(1, "qfsinf resp BCC: %d Offset %d",
5011 get_bcc(&pSMBr->hdr), data_offset);
5013 response_data = (FILE_SYSTEM_ALLOC_INFO *)
5014 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5016 le16_to_cpu(response_data->BytesPerSector) *
5017 le32_to_cpu(response_data->
5018 SectorsPerAllocationUnit);
5020 le32_to_cpu(response_data->TotalAllocationUnits);
5021 FSData->f_bfree = FSData->f_bavail =
5022 le32_to_cpu(response_data->FreeAllocationUnits);
5023 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5024 (unsigned long long)FSData->f_blocks,
5025 (unsigned long long)FSData->f_bfree,
5029 cifs_buf_release(pSMB);
5032 goto oldQFSInfoRetry;
5038 CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
5040 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5041 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5042 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5043 FILE_SYSTEM_INFO *response_data;
5045 int bytes_returned = 0;
5046 __u16 params, byte_count;
5048 cFYI(1, "In QFSInfo");
5050 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5055 params = 2; /* level */
5056 pSMB->TotalDataCount = 0;
5057 pSMB->MaxParameterCount = cpu_to_le16(2);
5058 pSMB->MaxDataCount = cpu_to_le16(1000);
5059 pSMB->MaxSetupCount = 0;
5063 pSMB->Reserved2 = 0;
5064 byte_count = params + 1 /* pad */ ;
5065 pSMB->TotalParameterCount = cpu_to_le16(params);
5066 pSMB->ParameterCount = pSMB->TotalParameterCount;
5067 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5068 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5069 pSMB->DataCount = 0;
5070 pSMB->DataOffset = 0;
5071 pSMB->SetupCount = 1;
5072 pSMB->Reserved3 = 0;
5073 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5074 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
5075 inc_rfc1001_len(pSMB, byte_count);
5076 pSMB->ByteCount = cpu_to_le16(byte_count);
5078 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5079 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5081 cFYI(1, "Send error in QFSInfo = %d", rc);
5082 } else { /* decode response */
5083 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5085 if (rc || get_bcc(&pSMBr->hdr) < 24)
5086 rc = -EIO; /* bad smb */
5088 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5092 *) (((char *) &pSMBr->hdr.Protocol) +
5095 le32_to_cpu(response_data->BytesPerSector) *
5096 le32_to_cpu(response_data->
5097 SectorsPerAllocationUnit);
5099 le64_to_cpu(response_data->TotalAllocationUnits);
5100 FSData->f_bfree = FSData->f_bavail =
5101 le64_to_cpu(response_data->FreeAllocationUnits);
5102 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5103 (unsigned long long)FSData->f_blocks,
5104 (unsigned long long)FSData->f_bfree,
5108 cifs_buf_release(pSMB);
5117 CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
5119 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5120 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5121 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5122 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5124 int bytes_returned = 0;
5125 __u16 params, byte_count;
5127 cFYI(1, "In QFSAttributeInfo");
5129 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5134 params = 2; /* level */
5135 pSMB->TotalDataCount = 0;
5136 pSMB->MaxParameterCount = cpu_to_le16(2);
5137 /* BB find exact max SMB PDU from sess structure BB */
5138 pSMB->MaxDataCount = cpu_to_le16(1000);
5139 pSMB->MaxSetupCount = 0;
5143 pSMB->Reserved2 = 0;
5144 byte_count = params + 1 /* pad */ ;
5145 pSMB->TotalParameterCount = cpu_to_le16(params);
5146 pSMB->ParameterCount = pSMB->TotalParameterCount;
5147 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5148 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5149 pSMB->DataCount = 0;
5150 pSMB->DataOffset = 0;
5151 pSMB->SetupCount = 1;
5152 pSMB->Reserved3 = 0;
5153 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5154 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
5155 inc_rfc1001_len(pSMB, byte_count);
5156 pSMB->ByteCount = cpu_to_le16(byte_count);
5158 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5159 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5161 cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
5162 } else { /* decode response */
5163 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5165 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5166 /* BB also check if enough bytes returned */
5167 rc = -EIO; /* bad smb */
5169 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5171 (FILE_SYSTEM_ATTRIBUTE_INFO
5172 *) (((char *) &pSMBr->hdr.Protocol) +
5174 memcpy(&tcon->fsAttrInfo, response_data,
5175 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
5178 cifs_buf_release(pSMB);
5181 goto QFSAttributeRetry;
5187 CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
5189 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5190 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5191 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5192 FILE_SYSTEM_DEVICE_INFO *response_data;
5194 int bytes_returned = 0;
5195 __u16 params, byte_count;
5197 cFYI(1, "In QFSDeviceInfo");
5199 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5204 params = 2; /* level */
5205 pSMB->TotalDataCount = 0;
5206 pSMB->MaxParameterCount = cpu_to_le16(2);
5207 /* BB find exact max SMB PDU from sess structure BB */
5208 pSMB->MaxDataCount = cpu_to_le16(1000);
5209 pSMB->MaxSetupCount = 0;
5213 pSMB->Reserved2 = 0;
5214 byte_count = params + 1 /* pad */ ;
5215 pSMB->TotalParameterCount = cpu_to_le16(params);
5216 pSMB->ParameterCount = pSMB->TotalParameterCount;
5217 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5218 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5220 pSMB->DataCount = 0;
5221 pSMB->DataOffset = 0;
5222 pSMB->SetupCount = 1;
5223 pSMB->Reserved3 = 0;
5224 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5225 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
5226 inc_rfc1001_len(pSMB, byte_count);
5227 pSMB->ByteCount = cpu_to_le16(byte_count);
5229 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5230 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5232 cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
5233 } else { /* decode response */
5234 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5236 if (rc || get_bcc(&pSMBr->hdr) <
5237 sizeof(FILE_SYSTEM_DEVICE_INFO))
5238 rc = -EIO; /* bad smb */
5240 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5242 (FILE_SYSTEM_DEVICE_INFO *)
5243 (((char *) &pSMBr->hdr.Protocol) +
5245 memcpy(&tcon->fsDevInfo, response_data,
5246 sizeof(FILE_SYSTEM_DEVICE_INFO));
5249 cifs_buf_release(pSMB);
5252 goto QFSDeviceRetry;
5258 CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
5260 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5261 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5262 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5263 FILE_SYSTEM_UNIX_INFO *response_data;
5265 int bytes_returned = 0;
5266 __u16 params, byte_count;
5268 cFYI(1, "In QFSUnixInfo");
5270 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5271 (void **) &pSMB, (void **) &pSMBr);
5275 params = 2; /* level */
5276 pSMB->TotalDataCount = 0;
5277 pSMB->DataCount = 0;
5278 pSMB->DataOffset = 0;
5279 pSMB->MaxParameterCount = cpu_to_le16(2);
5280 /* BB find exact max SMB PDU from sess structure BB */
5281 pSMB->MaxDataCount = cpu_to_le16(100);
5282 pSMB->MaxSetupCount = 0;
5286 pSMB->Reserved2 = 0;
5287 byte_count = params + 1 /* pad */ ;
5288 pSMB->ParameterCount = cpu_to_le16(params);
5289 pSMB->TotalParameterCount = pSMB->ParameterCount;
5290 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5291 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5292 pSMB->SetupCount = 1;
5293 pSMB->Reserved3 = 0;
5294 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5295 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
5296 inc_rfc1001_len(pSMB, byte_count);
5297 pSMB->ByteCount = cpu_to_le16(byte_count);
5299 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5300 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5302 cERROR(1, "Send error in QFSUnixInfo = %d", rc);
5303 } else { /* decode response */
5304 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5306 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5307 rc = -EIO; /* bad smb */
5309 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5311 (FILE_SYSTEM_UNIX_INFO
5312 *) (((char *) &pSMBr->hdr.Protocol) +
5314 memcpy(&tcon->fsUnixInfo, response_data,
5315 sizeof(FILE_SYSTEM_UNIX_INFO));
5318 cifs_buf_release(pSMB);
5328 CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
5330 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5331 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5332 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5334 int bytes_returned = 0;
5335 __u16 params, param_offset, offset, byte_count;
5337 cFYI(1, "In SETFSUnixInfo");
5339 /* BB switch to small buf init to save memory */
5340 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5341 (void **) &pSMB, (void **) &pSMBr);
5345 params = 4; /* 2 bytes zero followed by info level. */
5346 pSMB->MaxSetupCount = 0;
5350 pSMB->Reserved2 = 0;
5351 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5353 offset = param_offset + params;
5355 pSMB->MaxParameterCount = cpu_to_le16(4);
5356 /* BB find exact max SMB PDU from sess structure BB */
5357 pSMB->MaxDataCount = cpu_to_le16(100);
5358 pSMB->SetupCount = 1;
5359 pSMB->Reserved3 = 0;
5360 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5361 byte_count = 1 /* pad */ + params + 12;
5363 pSMB->DataCount = cpu_to_le16(12);
5364 pSMB->ParameterCount = cpu_to_le16(params);
5365 pSMB->TotalDataCount = pSMB->DataCount;
5366 pSMB->TotalParameterCount = pSMB->ParameterCount;
5367 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5368 pSMB->DataOffset = cpu_to_le16(offset);
5372 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5375 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5376 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5377 pSMB->ClientUnixCap = cpu_to_le64(cap);
5379 inc_rfc1001_len(pSMB, byte_count);
5380 pSMB->ByteCount = cpu_to_le16(byte_count);
5382 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5383 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5385 cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
5386 } else { /* decode response */
5387 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5389 rc = -EIO; /* bad smb */
5391 cifs_buf_release(pSMB);
5394 goto SETFSUnixRetry;
5402 CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
5403 struct kstatfs *FSData)
5405 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5406 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5407 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5408 FILE_SYSTEM_POSIX_INFO *response_data;
5410 int bytes_returned = 0;
5411 __u16 params, byte_count;
5413 cFYI(1, "In QFSPosixInfo");
5415 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5420 params = 2; /* level */
5421 pSMB->TotalDataCount = 0;
5422 pSMB->DataCount = 0;
5423 pSMB->DataOffset = 0;
5424 pSMB->MaxParameterCount = cpu_to_le16(2);
5425 /* BB find exact max SMB PDU from sess structure BB */
5426 pSMB->MaxDataCount = cpu_to_le16(100);
5427 pSMB->MaxSetupCount = 0;
5431 pSMB->Reserved2 = 0;
5432 byte_count = params + 1 /* pad */ ;
5433 pSMB->ParameterCount = cpu_to_le16(params);
5434 pSMB->TotalParameterCount = pSMB->ParameterCount;
5435 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5436 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5437 pSMB->SetupCount = 1;
5438 pSMB->Reserved3 = 0;
5439 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5440 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
5441 inc_rfc1001_len(pSMB, byte_count);
5442 pSMB->ByteCount = cpu_to_le16(byte_count);
5444 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5445 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5447 cFYI(1, "Send error in QFSUnixInfo = %d", rc);
5448 } else { /* decode response */
5449 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5451 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5452 rc = -EIO; /* bad smb */
5454 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5456 (FILE_SYSTEM_POSIX_INFO
5457 *) (((char *) &pSMBr->hdr.Protocol) +
5460 le32_to_cpu(response_data->BlockSize);
5462 le64_to_cpu(response_data->TotalBlocks);
5464 le64_to_cpu(response_data->BlocksAvail);
5465 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
5466 FSData->f_bavail = FSData->f_bfree;
5469 le64_to_cpu(response_data->UserBlocksAvail);
5471 if (response_data->TotalFileNodes != cpu_to_le64(-1))
5473 le64_to_cpu(response_data->TotalFileNodes);
5474 if (response_data->FreeFileNodes != cpu_to_le64(-1))
5476 le64_to_cpu(response_data->FreeFileNodes);
5479 cifs_buf_release(pSMB);
5488 /* We can not use write of zero bytes trick to
5489 set file size due to need for large file support. Also note that
5490 this SetPathInfo is preferred to SetFileInfo based method in next
5491 routine which is only needed to work around a sharing violation bug
5492 in Samba which this routine can run into */
5495 CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
5496 __u64 size, bool SetAllocation,
5497 const struct nls_table *nls_codepage, int remap)
5499 struct smb_com_transaction2_spi_req *pSMB = NULL;
5500 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5501 struct file_end_of_file_info *parm_data;
5504 int bytes_returned = 0;
5505 __u16 params, byte_count, data_count, param_offset, offset;
5507 cFYI(1, "In SetEOF");
5509 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5514 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5516 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5517 PATH_MAX, nls_codepage, remap);
5518 name_len++; /* trailing null */
5520 } else { /* BB improve the check for buffer overruns BB */
5521 name_len = strnlen(fileName, PATH_MAX);
5522 name_len++; /* trailing null */
5523 strncpy(pSMB->FileName, fileName, name_len);
5525 params = 6 + name_len;
5526 data_count = sizeof(struct file_end_of_file_info);
5527 pSMB->MaxParameterCount = cpu_to_le16(2);
5528 pSMB->MaxDataCount = cpu_to_le16(4100);
5529 pSMB->MaxSetupCount = 0;
5533 pSMB->Reserved2 = 0;
5534 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5535 InformationLevel) - 4;
5536 offset = param_offset + params;
5537 if (SetAllocation) {
5538 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5539 pSMB->InformationLevel =
5540 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5542 pSMB->InformationLevel =
5543 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5544 } else /* Set File Size */ {
5545 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5546 pSMB->InformationLevel =
5547 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5549 pSMB->InformationLevel =
5550 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5554 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5556 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5557 pSMB->DataOffset = cpu_to_le16(offset);
5558 pSMB->SetupCount = 1;
5559 pSMB->Reserved3 = 0;
5560 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5561 byte_count = 3 /* pad */ + params + data_count;
5562 pSMB->DataCount = cpu_to_le16(data_count);
5563 pSMB->TotalDataCount = pSMB->DataCount;
5564 pSMB->ParameterCount = cpu_to_le16(params);
5565 pSMB->TotalParameterCount = pSMB->ParameterCount;
5566 pSMB->Reserved4 = 0;
5567 inc_rfc1001_len(pSMB, byte_count);
5568 parm_data->FileSize = cpu_to_le64(size);
5569 pSMB->ByteCount = cpu_to_le16(byte_count);
5570 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5571 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5573 cFYI(1, "SetPathInfo (file size) returned %d", rc);
5575 cifs_buf_release(pSMB);
5584 CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
5585 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
5587 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5588 struct file_end_of_file_info *parm_data;
5590 __u16 params, param_offset, offset, byte_count, count;
5592 cFYI(1, "SetFileSize (via SetFileInfo) %lld",
5594 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5599 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5600 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5603 pSMB->MaxSetupCount = 0;
5607 pSMB->Reserved2 = 0;
5608 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5609 offset = param_offset + params;
5611 count = sizeof(struct file_end_of_file_info);
5612 pSMB->MaxParameterCount = cpu_to_le16(2);
5613 /* BB find exact max SMB PDU from sess structure BB */
5614 pSMB->MaxDataCount = cpu_to_le16(1000);
5615 pSMB->SetupCount = 1;
5616 pSMB->Reserved3 = 0;
5617 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5618 byte_count = 3 /* pad */ + params + count;
5619 pSMB->DataCount = cpu_to_le16(count);
5620 pSMB->ParameterCount = cpu_to_le16(params);
5621 pSMB->TotalDataCount = pSMB->DataCount;
5622 pSMB->TotalParameterCount = pSMB->ParameterCount;
5623 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5625 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5627 pSMB->DataOffset = cpu_to_le16(offset);
5628 parm_data->FileSize = cpu_to_le64(size);
5630 if (SetAllocation) {
5631 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5632 pSMB->InformationLevel =
5633 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5635 pSMB->InformationLevel =
5636 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5637 } else /* Set File Size */ {
5638 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5639 pSMB->InformationLevel =
5640 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5642 pSMB->InformationLevel =
5643 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5645 pSMB->Reserved4 = 0;
5646 inc_rfc1001_len(pSMB, byte_count);
5647 pSMB->ByteCount = cpu_to_le16(byte_count);
5648 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5650 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
5653 /* Note: On -EAGAIN error only caller can retry on handle based calls
5654 since file handle passed in no longer valid */
5659 /* Some legacy servers such as NT4 require that the file times be set on
5660 an open handle, rather than by pathname - this is awkward due to
5661 potential access conflicts on the open, but it is unavoidable for these
5662 old servers since the only other choice is to go from 100 nanosecond DCE
5663 time and resort to the original setpathinfo level which takes the ancient
5664 DOS time format with 2 second granularity */
5666 CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
5667 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5669 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5672 __u16 params, param_offset, offset, byte_count, count;
5674 cFYI(1, "Set Times (via SetFileInfo)");
5675 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5680 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5681 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5684 pSMB->MaxSetupCount = 0;
5688 pSMB->Reserved2 = 0;
5689 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5690 offset = param_offset + params;
5692 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5694 count = sizeof(FILE_BASIC_INFO);
5695 pSMB->MaxParameterCount = cpu_to_le16(2);
5696 /* BB find max SMB PDU from sess */
5697 pSMB->MaxDataCount = cpu_to_le16(1000);
5698 pSMB->SetupCount = 1;
5699 pSMB->Reserved3 = 0;
5700 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5701 byte_count = 3 /* pad */ + params + count;
5702 pSMB->DataCount = cpu_to_le16(count);
5703 pSMB->ParameterCount = cpu_to_le16(params);
5704 pSMB->TotalDataCount = pSMB->DataCount;
5705 pSMB->TotalParameterCount = pSMB->ParameterCount;
5706 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5707 pSMB->DataOffset = cpu_to_le16(offset);
5709 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5710 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5712 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5713 pSMB->Reserved4 = 0;
5714 inc_rfc1001_len(pSMB, byte_count);
5715 pSMB->ByteCount = cpu_to_le16(byte_count);
5716 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5717 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5719 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
5721 /* Note: On -EAGAIN error only caller can retry on handle based calls
5722 since file handle passed in no longer valid */
5728 CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
5729 bool delete_file, __u16 fid, __u32 pid_of_opener)
5731 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5734 __u16 params, param_offset, offset, byte_count, count;
5736 cFYI(1, "Set File Disposition (via SetFileInfo)");
5737 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5742 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5743 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5746 pSMB->MaxSetupCount = 0;
5750 pSMB->Reserved2 = 0;
5751 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5752 offset = param_offset + params;
5754 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5757 pSMB->MaxParameterCount = cpu_to_le16(2);
5758 /* BB find max SMB PDU from sess */
5759 pSMB->MaxDataCount = cpu_to_le16(1000);
5760 pSMB->SetupCount = 1;
5761 pSMB->Reserved3 = 0;
5762 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5763 byte_count = 3 /* pad */ + params + count;
5764 pSMB->DataCount = cpu_to_le16(count);
5765 pSMB->ParameterCount = cpu_to_le16(params);
5766 pSMB->TotalDataCount = pSMB->DataCount;
5767 pSMB->TotalParameterCount = pSMB->ParameterCount;
5768 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5769 pSMB->DataOffset = cpu_to_le16(offset);
5771 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5772 pSMB->Reserved4 = 0;
5773 inc_rfc1001_len(pSMB, byte_count);
5774 pSMB->ByteCount = cpu_to_le16(byte_count);
5775 *data_offset = delete_file ? 1 : 0;
5776 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5778 cFYI(1, "Send error in SetFileDisposition = %d", rc);
5784 CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
5785 const char *fileName, const FILE_BASIC_INFO *data,
5786 const struct nls_table *nls_codepage, int remap)
5788 TRANSACTION2_SPI_REQ *pSMB = NULL;
5789 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5792 int bytes_returned = 0;
5794 __u16 params, param_offset, offset, byte_count, count;
5796 cFYI(1, "In SetTimes");
5799 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5804 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5806 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5807 PATH_MAX, nls_codepage, remap);
5808 name_len++; /* trailing null */
5810 } else { /* BB improve the check for buffer overruns BB */
5811 name_len = strnlen(fileName, PATH_MAX);
5812 name_len++; /* trailing null */
5813 strncpy(pSMB->FileName, fileName, name_len);
5816 params = 6 + name_len;
5817 count = sizeof(FILE_BASIC_INFO);
5818 pSMB->MaxParameterCount = cpu_to_le16(2);
5819 /* BB find max SMB PDU from sess structure BB */
5820 pSMB->MaxDataCount = cpu_to_le16(1000);
5821 pSMB->MaxSetupCount = 0;
5825 pSMB->Reserved2 = 0;
5826 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5827 InformationLevel) - 4;
5828 offset = param_offset + params;
5829 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5830 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5831 pSMB->DataOffset = cpu_to_le16(offset);
5832 pSMB->SetupCount = 1;
5833 pSMB->Reserved3 = 0;
5834 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5835 byte_count = 3 /* pad */ + params + count;
5837 pSMB->DataCount = cpu_to_le16(count);
5838 pSMB->ParameterCount = cpu_to_le16(params);
5839 pSMB->TotalDataCount = pSMB->DataCount;
5840 pSMB->TotalParameterCount = pSMB->ParameterCount;
5841 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5842 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5844 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5845 pSMB->Reserved4 = 0;
5846 inc_rfc1001_len(pSMB, byte_count);
5847 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5848 pSMB->ByteCount = cpu_to_le16(byte_count);
5849 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5850 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5852 cFYI(1, "SetPathInfo (times) returned %d", rc);
5854 cifs_buf_release(pSMB);
5862 /* Can not be used to set time stamps yet (due to old DOS time format) */
5863 /* Can be used to set attributes */
5864 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5865 handling it anyway and NT4 was what we thought it would be needed for
5866 Do not delete it until we prove whether needed for Win9x though */
5868 CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
5869 __u16 dos_attrs, const struct nls_table *nls_codepage)
5871 SETATTR_REQ *pSMB = NULL;
5872 SETATTR_RSP *pSMBr = NULL;
5877 cFYI(1, "In SetAttrLegacy");
5880 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5885 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5887 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5888 PATH_MAX, nls_codepage);
5889 name_len++; /* trailing null */
5891 } else { /* BB improve the check for buffer overruns BB */
5892 name_len = strnlen(fileName, PATH_MAX);
5893 name_len++; /* trailing null */
5894 strncpy(pSMB->fileName, fileName, name_len);
5896 pSMB->attr = cpu_to_le16(dos_attrs);
5897 pSMB->BufferFormat = 0x04;
5898 inc_rfc1001_len(pSMB, name_len + 1);
5899 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5900 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5901 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5903 cFYI(1, "Error in LegacySetAttr = %d", rc);
5905 cifs_buf_release(pSMB);
5908 goto SetAttrLgcyRetry;
5912 #endif /* temporarily unneeded SetAttr legacy function */
5915 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5916 const struct cifs_unix_set_info_args *args)
5918 u64 mode = args->mode;
5921 * Samba server ignores set of file size to zero due to bugs in some
5922 * older clients, but we should be precise - we use SetFileSize to
5923 * set file size and do not want to truncate file size to zero
5924 * accidentally as happened on one Samba server beta by putting
5925 * zero instead of -1 here
5927 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5928 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5929 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5930 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5931 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5932 data_offset->Uid = cpu_to_le64(args->uid);
5933 data_offset->Gid = cpu_to_le64(args->gid);
5934 /* better to leave device as zero when it is */
5935 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5936 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5937 data_offset->Permissions = cpu_to_le64(mode);
5940 data_offset->Type = cpu_to_le32(UNIX_FILE);
5941 else if (S_ISDIR(mode))
5942 data_offset->Type = cpu_to_le32(UNIX_DIR);
5943 else if (S_ISLNK(mode))
5944 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5945 else if (S_ISCHR(mode))
5946 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5947 else if (S_ISBLK(mode))
5948 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5949 else if (S_ISFIFO(mode))
5950 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5951 else if (S_ISSOCK(mode))
5952 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5956 CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
5957 const struct cifs_unix_set_info_args *args,
5958 u16 fid, u32 pid_of_opener)
5960 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5961 FILE_UNIX_BASIC_INFO *data_offset;
5963 u16 params, param_offset, offset, byte_count, count;
5965 cFYI(1, "Set Unix Info (via SetFileInfo)");
5966 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5971 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5972 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5975 pSMB->MaxSetupCount = 0;
5979 pSMB->Reserved2 = 0;
5980 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5981 offset = param_offset + params;
5983 data_offset = (FILE_UNIX_BASIC_INFO *)
5984 ((char *)(&pSMB->hdr.Protocol) + offset);
5985 count = sizeof(FILE_UNIX_BASIC_INFO);
5987 pSMB->MaxParameterCount = cpu_to_le16(2);
5988 /* BB find max SMB PDU from sess */
5989 pSMB->MaxDataCount = cpu_to_le16(1000);
5990 pSMB->SetupCount = 1;
5991 pSMB->Reserved3 = 0;
5992 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5993 byte_count = 3 /* pad */ + params + count;
5994 pSMB->DataCount = cpu_to_le16(count);
5995 pSMB->ParameterCount = cpu_to_le16(params);
5996 pSMB->TotalDataCount = pSMB->DataCount;
5997 pSMB->TotalParameterCount = pSMB->ParameterCount;
5998 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5999 pSMB->DataOffset = cpu_to_le16(offset);
6001 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6002 pSMB->Reserved4 = 0;
6003 inc_rfc1001_len(pSMB, byte_count);
6004 pSMB->ByteCount = cpu_to_le16(byte_count);
6006 cifs_fill_unix_set_info(data_offset, args);
6008 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
6010 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
6012 /* Note: On -EAGAIN error only caller can retry on handle based calls
6013 since file handle passed in no longer valid */
6019 CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
6020 const struct cifs_unix_set_info_args *args,
6021 const struct nls_table *nls_codepage, int remap)
6023 TRANSACTION2_SPI_REQ *pSMB = NULL;
6024 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6027 int bytes_returned = 0;
6028 FILE_UNIX_BASIC_INFO *data_offset;
6029 __u16 params, param_offset, offset, count, byte_count;
6031 cFYI(1, "In SetUID/GID/Mode");
6033 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6038 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6040 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6041 PATH_MAX, nls_codepage, remap);
6042 name_len++; /* trailing null */
6044 } else { /* BB improve the check for buffer overruns BB */
6045 name_len = strnlen(fileName, PATH_MAX);
6046 name_len++; /* trailing null */
6047 strncpy(pSMB->FileName, fileName, name_len);
6050 params = 6 + name_len;
6051 count = sizeof(FILE_UNIX_BASIC_INFO);
6052 pSMB->MaxParameterCount = cpu_to_le16(2);
6053 /* BB find max SMB PDU from sess structure BB */
6054 pSMB->MaxDataCount = cpu_to_le16(1000);
6055 pSMB->MaxSetupCount = 0;
6059 pSMB->Reserved2 = 0;
6060 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6061 InformationLevel) - 4;
6062 offset = param_offset + params;
6064 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6066 memset(data_offset, 0, count);
6067 pSMB->DataOffset = cpu_to_le16(offset);
6068 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6069 pSMB->SetupCount = 1;
6070 pSMB->Reserved3 = 0;
6071 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6072 byte_count = 3 /* pad */ + params + count;
6073 pSMB->ParameterCount = cpu_to_le16(params);
6074 pSMB->DataCount = cpu_to_le16(count);
6075 pSMB->TotalParameterCount = pSMB->ParameterCount;
6076 pSMB->TotalDataCount = pSMB->DataCount;
6077 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6078 pSMB->Reserved4 = 0;
6079 inc_rfc1001_len(pSMB, byte_count);
6081 cifs_fill_unix_set_info(data_offset, args);
6083 pSMB->ByteCount = cpu_to_le16(byte_count);
6084 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6085 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6087 cFYI(1, "SetPathInfo (perms) returned %d", rc);
6089 cifs_buf_release(pSMB);
6095 #ifdef CONFIG_CIFS_XATTR
6097 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6098 * function used by listxattr and getxattr type calls. When ea_name is set,
6099 * it looks for that attribute name and stuffs that value into the EAData
6100 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6101 * buffer. In both cases, the return value is either the length of the
6102 * resulting data or a negative error code. If EAData is a NULL pointer then
6103 * the data isn't copied to it, but the length is returned.
6106 CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
6107 const unsigned char *searchName, const unsigned char *ea_name,
6108 char *EAData, size_t buf_size,
6109 const struct nls_table *nls_codepage, int remap)
6111 /* BB assumes one setup word */
6112 TRANSACTION2_QPI_REQ *pSMB = NULL;
6113 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6117 struct fealist *ea_response_data;
6118 struct fea *temp_fea;
6121 __u16 params, byte_count, data_offset;
6122 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
6124 cFYI(1, "In Query All EAs path %s", searchName);
6126 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6131 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6133 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6134 PATH_MAX, nls_codepage, remap);
6135 list_len++; /* trailing null */
6137 } else { /* BB improve the check for buffer overruns BB */
6138 list_len = strnlen(searchName, PATH_MAX);
6139 list_len++; /* trailing null */
6140 strncpy(pSMB->FileName, searchName, list_len);
6143 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
6144 pSMB->TotalDataCount = 0;
6145 pSMB->MaxParameterCount = cpu_to_le16(2);
6146 /* BB find exact max SMB PDU from sess structure BB */
6147 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
6148 pSMB->MaxSetupCount = 0;
6152 pSMB->Reserved2 = 0;
6153 pSMB->ParameterOffset = cpu_to_le16(offsetof(
6154 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
6155 pSMB->DataCount = 0;
6156 pSMB->DataOffset = 0;
6157 pSMB->SetupCount = 1;
6158 pSMB->Reserved3 = 0;
6159 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6160 byte_count = params + 1 /* pad */ ;
6161 pSMB->TotalParameterCount = cpu_to_le16(params);
6162 pSMB->ParameterCount = pSMB->TotalParameterCount;
6163 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6164 pSMB->Reserved4 = 0;
6165 inc_rfc1001_len(pSMB, byte_count);
6166 pSMB->ByteCount = cpu_to_le16(byte_count);
6168 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6169 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6171 cFYI(1, "Send error in QueryAllEAs = %d", rc);
6176 /* BB also check enough total bytes returned */
6177 /* BB we need to improve the validity checking
6178 of these trans2 responses */
6180 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6181 if (rc || get_bcc(&pSMBr->hdr) < 4) {
6182 rc = -EIO; /* bad smb */
6186 /* check that length of list is not more than bcc */
6187 /* check that each entry does not go beyond length
6189 /* check that each element of each entry does not
6190 go beyond end of list */
6191 /* validate_trans2_offsets() */
6192 /* BB check if start of smb + data_offset > &bcc+ bcc */
6194 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6195 ea_response_data = (struct fealist *)
6196 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6198 list_len = le32_to_cpu(ea_response_data->list_len);
6199 cFYI(1, "ea length %d", list_len);
6200 if (list_len <= 8) {
6201 cFYI(1, "empty EA list returned from server");
6205 /* make sure list_len doesn't go past end of SMB */
6206 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
6207 if ((char *)ea_response_data + list_len > end_of_smb) {
6208 cFYI(1, "EA list appears to go beyond SMB");
6213 /* account for ea list len */
6215 temp_fea = ea_response_data->list;
6216 temp_ptr = (char *)temp_fea;
6217 while (list_len > 0) {
6218 unsigned int name_len;
6223 /* make sure we can read name_len and value_len */
6225 cFYI(1, "EA entry goes beyond length of list");
6230 name_len = temp_fea->name_len;
6231 value_len = le16_to_cpu(temp_fea->value_len);
6232 list_len -= name_len + 1 + value_len;
6234 cFYI(1, "EA entry goes beyond length of list");
6240 if (ea_name_len == name_len &&
6241 memcmp(ea_name, temp_ptr, name_len) == 0) {
6242 temp_ptr += name_len + 1;
6246 if ((size_t)value_len > buf_size) {
6250 memcpy(EAData, temp_ptr, value_len);
6254 /* account for prefix user. and trailing null */
6255 rc += (5 + 1 + name_len);
6256 if (rc < (int) buf_size) {
6257 memcpy(EAData, "user.", 5);
6259 memcpy(EAData, temp_ptr, name_len);
6261 /* null terminate name */
6264 } else if (buf_size == 0) {
6265 /* skip copy - calc size only */
6267 /* stop before overrun buffer */
6272 temp_ptr += name_len + 1 + value_len;
6273 temp_fea = (struct fea *)temp_ptr;
6276 /* didn't find the named attribute */
6281 cifs_buf_release(pSMB);
6289 CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
6290 const char *ea_name, const void *ea_value,
6291 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6294 struct smb_com_transaction2_spi_req *pSMB = NULL;
6295 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6296 struct fealist *parm_data;
6299 int bytes_returned = 0;
6300 __u16 params, param_offset, byte_count, offset, count;
6302 cFYI(1, "In SetEA");
6304 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6309 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6311 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6312 PATH_MAX, nls_codepage, remap);
6313 name_len++; /* trailing null */
6315 } else { /* BB improve the check for buffer overruns BB */
6316 name_len = strnlen(fileName, PATH_MAX);
6317 name_len++; /* trailing null */
6318 strncpy(pSMB->FileName, fileName, name_len);
6321 params = 6 + name_len;
6323 /* done calculating parms using name_len of file name,
6324 now use name_len to calculate length of ea name
6325 we are going to create in the inode xattrs */
6326 if (ea_name == NULL)
6329 name_len = strnlen(ea_name, 255);
6331 count = sizeof(*parm_data) + ea_value_len + name_len;
6332 pSMB->MaxParameterCount = cpu_to_le16(2);
6333 /* BB find max SMB PDU from sess */
6334 pSMB->MaxDataCount = cpu_to_le16(1000);
6335 pSMB->MaxSetupCount = 0;
6339 pSMB->Reserved2 = 0;
6340 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6341 InformationLevel) - 4;
6342 offset = param_offset + params;
6343 pSMB->InformationLevel =
6344 cpu_to_le16(SMB_SET_FILE_EA);
6347 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6349 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6350 pSMB->DataOffset = cpu_to_le16(offset);
6351 pSMB->SetupCount = 1;
6352 pSMB->Reserved3 = 0;
6353 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6354 byte_count = 3 /* pad */ + params + count;
6355 pSMB->DataCount = cpu_to_le16(count);
6356 parm_data->list_len = cpu_to_le32(count);
6357 parm_data->list[0].EA_flags = 0;
6358 /* we checked above that name len is less than 255 */
6359 parm_data->list[0].name_len = (__u8)name_len;
6360 /* EA names are always ASCII */
6362 strncpy(parm_data->list[0].name, ea_name, name_len);
6363 parm_data->list[0].name[name_len] = 0;
6364 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6365 /* caller ensures that ea_value_len is less than 64K but
6366 we need to ensure that it fits within the smb */
6368 /*BB add length check to see if it would fit in
6369 negotiated SMB buffer size BB */
6370 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6372 memcpy(parm_data->list[0].name+name_len+1,
6373 ea_value, ea_value_len);
6375 pSMB->TotalDataCount = pSMB->DataCount;
6376 pSMB->ParameterCount = cpu_to_le16(params);
6377 pSMB->TotalParameterCount = pSMB->ParameterCount;
6378 pSMB->Reserved4 = 0;
6379 inc_rfc1001_len(pSMB, byte_count);
6380 pSMB->ByteCount = cpu_to_le16(byte_count);
6381 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6382 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6384 cFYI(1, "SetPathInfo (EA) returned %d", rc);
6386 cifs_buf_release(pSMB);
6395 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6397 * Years ago the kernel added a "dnotify" function for Samba server,
6398 * to allow network clients (such as Windows) to display updated
6399 * lists of files in directory listings automatically when
6400 * files are added by one user when another user has the
6401 * same directory open on their desktop. The Linux cifs kernel
6402 * client hooked into the kernel side of this interface for
6403 * the same reason, but ironically when the VFS moved from
6404 * "dnotify" to "inotify" it became harder to plug in Linux
6405 * network file system clients (the most obvious use case
6406 * for notify interfaces is when multiple users can update
6407 * the contents of the same directory - exactly what network
6408 * file systems can do) although the server (Samba) could
6409 * still use it. For the short term we leave the worker
6410 * function ifdeffed out (below) until inotify is fixed
6411 * in the VFS to make it easier to plug in network file
6412 * system clients. If inotify turns out to be permanently
6413 * incompatible for network fs clients, we could instead simply
6414 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6416 int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
6417 const int notify_subdirs, const __u16 netfid,
6418 __u32 filter, struct file *pfile, int multishot,
6419 const struct nls_table *nls_codepage)
6422 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6423 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6424 struct dir_notify_req *dnotify_req;
6427 cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
6428 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6433 pSMB->TotalParameterCount = 0 ;
6434 pSMB->TotalDataCount = 0;
6435 pSMB->MaxParameterCount = cpu_to_le32(2);
6436 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
6437 pSMB->MaxSetupCount = 4;
6439 pSMB->ParameterOffset = 0;
6440 pSMB->DataCount = 0;
6441 pSMB->DataOffset = 0;
6442 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6443 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6444 pSMB->ParameterCount = pSMB->TotalParameterCount;
6446 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6447 pSMB->Reserved2 = 0;
6448 pSMB->CompletionFilter = cpu_to_le32(filter);
6449 pSMB->Fid = netfid; /* file handle always le */
6450 pSMB->ByteCount = 0;
6452 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6453 (struct smb_hdr *)pSMBr, &bytes_returned,
6456 cFYI(1, "Error in Notify = %d", rc);
6458 /* Add file to outstanding requests */
6459 /* BB change to kmem cache alloc */
6460 dnotify_req = kmalloc(
6461 sizeof(struct dir_notify_req),
6464 dnotify_req->Pid = pSMB->hdr.Pid;
6465 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6466 dnotify_req->Mid = pSMB->hdr.Mid;
6467 dnotify_req->Tid = pSMB->hdr.Tid;
6468 dnotify_req->Uid = pSMB->hdr.Uid;
6469 dnotify_req->netfid = netfid;
6470 dnotify_req->pfile = pfile;
6471 dnotify_req->filter = filter;
6472 dnotify_req->multishot = multishot;
6473 spin_lock(&GlobalMid_Lock);
6474 list_add_tail(&dnotify_req->lhead,
6475 &GlobalDnotifyReqList);
6476 spin_unlock(&GlobalMid_Lock);
6480 cifs_buf_release(pSMB);
6483 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */