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 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
1418 int remaining = rfclen + 4 - server->total_read;
1419 struct cifs_readdata *rdata = mid->callback_data;
1421 while (remaining > 0) {
1424 length = cifs_read_from_socket(server, server->bigbuf,
1425 min_t(unsigned int, remaining,
1426 CIFSMaxBufSize + max_header_size()));
1429 server->total_read += length;
1430 remaining -= length;
1433 dequeue_mid(mid, rdata->result);
1437 static inline size_t
1440 return sizeof(READ_RSP);
1443 static inline unsigned int
1444 read_data_offset(char *buf)
1446 READ_RSP *rsp = (READ_RSP *)buf;
1447 return le16_to_cpu(rsp->DataOffset);
1450 static inline unsigned int
1451 read_data_length(char *buf)
1453 READ_RSP *rsp = (READ_RSP *)buf;
1454 return (le16_to_cpu(rsp->DataLengthHigh) << 16) +
1455 le16_to_cpu(rsp->DataLength);
1459 cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1462 unsigned int data_offset, remaining, data_len;
1463 struct cifs_readdata *rdata = mid->callback_data;
1464 char *buf = server->smallbuf;
1465 unsigned int buflen = get_rfc1002_length(buf) + 4;
1468 struct page *page, *tpage;
1470 cFYI(1, "%s: mid=%llu offset=%llu bytes=%u", __func__,
1471 mid->mid, rdata->offset, rdata->bytes);
1474 * read the rest of READ_RSP header (sans Data array), or whatever we
1475 * can if there's not enough data. At this point, we've read down to
1478 len = min_t(unsigned int, buflen, read_rsp_size()) - header_size() + 1;
1480 rdata->iov[0].iov_base = buf + header_size() - 1;
1481 rdata->iov[0].iov_len = len;
1483 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1486 server->total_read += length;
1488 /* Was the SMB read successful? */
1489 rdata->result = map_smb_to_linux_error(buf, false);
1490 if (rdata->result != 0) {
1491 cFYI(1, "%s: server returned error %d", __func__,
1493 return cifs_readv_discard(server, mid);
1496 /* Is there enough to get to the rest of the READ_RSP header? */
1497 if (server->total_read < read_rsp_size()) {
1498 cFYI(1, "%s: server returned short header. got=%u expected=%zu",
1499 __func__, server->total_read, read_rsp_size());
1500 rdata->result = -EIO;
1501 return cifs_readv_discard(server, mid);
1504 data_offset = read_data_offset(buf) + 4;
1505 if (data_offset < server->total_read) {
1507 * win2k8 sometimes sends an offset of 0 when the read
1508 * is beyond the EOF. Treat it as if the data starts just after
1511 cFYI(1, "%s: data offset (%u) inside read response header",
1512 __func__, data_offset);
1513 data_offset = server->total_read;
1514 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1515 /* data_offset is beyond the end of smallbuf */
1516 cFYI(1, "%s: data offset (%u) beyond end of smallbuf",
1517 __func__, data_offset);
1518 rdata->result = -EIO;
1519 return cifs_readv_discard(server, mid);
1522 cFYI(1, "%s: total_read=%u data_offset=%u", __func__,
1523 server->total_read, data_offset);
1525 len = data_offset - server->total_read;
1527 /* read any junk before data into the rest of smallbuf */
1528 rdata->iov[0].iov_base = buf + server->total_read;
1529 rdata->iov[0].iov_len = len;
1530 length = cifs_readv_from_socket(server, rdata->iov, 1, len);
1533 server->total_read += length;
1536 /* set up first iov for signature check */
1537 rdata->iov[0].iov_base = buf;
1538 rdata->iov[0].iov_len = server->total_read;
1539 cFYI(1, "0: iov_base=%p iov_len=%zu",
1540 rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1542 /* how much data is in the response? */
1543 data_len = read_data_length(buf);
1544 if (data_offset + data_len > buflen) {
1545 /* data_len is corrupt -- discard frame */
1546 rdata->result = -EIO;
1547 return cifs_readv_discard(server, mid);
1550 /* marshal up the page array */
1552 remaining = data_len;
1555 /* determine the eof that the server (probably) has */
1556 eof = CIFS_I(rdata->mapping->host)->server_eof;
1557 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
1558 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
1560 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1561 if (remaining >= PAGE_CACHE_SIZE) {
1562 /* enough data to fill the page */
1563 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1564 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
1565 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1566 rdata->nr_iov, page->index,
1567 rdata->iov[rdata->nr_iov].iov_base,
1568 rdata->iov[rdata->nr_iov].iov_len);
1570 len += PAGE_CACHE_SIZE;
1571 remaining -= PAGE_CACHE_SIZE;
1572 } else if (remaining > 0) {
1573 /* enough for partial page, fill and zero the rest */
1574 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
1575 rdata->iov[rdata->nr_iov].iov_len = remaining;
1576 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
1577 rdata->nr_iov, page->index,
1578 rdata->iov[rdata->nr_iov].iov_base,
1579 rdata->iov[rdata->nr_iov].iov_len);
1580 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
1581 '\0', PAGE_CACHE_SIZE - remaining);
1585 } else if (page->index > eof_index) {
1587 * The VFS will not try to do readahead past the
1588 * i_size, but it's possible that we have outstanding
1589 * writes with gaps in the middle and the i_size hasn't
1590 * caught up yet. Populate those with zeroed out pages
1591 * to prevent the VFS from repeatedly attempting to
1592 * fill them until the writes are flushed.
1594 zero_user(page, 0, PAGE_CACHE_SIZE);
1595 list_del(&page->lru);
1596 lru_cache_add_file(page);
1597 flush_dcache_page(page);
1598 SetPageUptodate(page);
1600 page_cache_release(page);
1602 /* no need to hold page hostage */
1603 list_del(&page->lru);
1604 lru_cache_add_file(page);
1606 page_cache_release(page);
1610 /* issue the read if we have any iovecs left to fill */
1611 if (rdata->nr_iov > 1) {
1612 length = cifs_readv_from_socket(server, &rdata->iov[1],
1613 rdata->nr_iov - 1, len);
1616 server->total_read += length;
1621 rdata->bytes = length;
1623 cFYI(1, "total_read=%u buflen=%u remaining=%u", server->total_read,
1626 /* discard anything left over */
1627 if (server->total_read < buflen)
1628 return cifs_readv_discard(server, mid);
1630 dequeue_mid(mid, false);
1635 cifs_readv_complete(struct work_struct *work)
1637 struct cifs_readdata *rdata = container_of(work,
1638 struct cifs_readdata, work);
1639 struct page *page, *tpage;
1641 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
1642 list_del(&page->lru);
1643 lru_cache_add_file(page);
1645 if (rdata->result == 0) {
1647 flush_dcache_page(page);
1648 SetPageUptodate(page);
1653 if (rdata->result == 0)
1654 cifs_readpage_to_fscache(rdata->mapping->host, page);
1656 page_cache_release(page);
1658 cifs_readdata_free(rdata);
1662 cifs_readv_callback(struct mid_q_entry *mid)
1664 struct cifs_readdata *rdata = mid->callback_data;
1665 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1666 struct TCP_Server_Info *server = tcon->ses->server;
1668 cFYI(1, "%s: mid=%llu state=%d result=%d bytes=%u", __func__,
1669 mid->mid, mid->mid_state, rdata->result, rdata->bytes);
1671 switch (mid->mid_state) {
1672 case MID_RESPONSE_RECEIVED:
1673 /* result already set, check signature */
1674 if (server->sec_mode &
1675 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1676 if (cifs_verify_signature(rdata->iov, rdata->nr_iov,
1677 server, mid->sequence_number + 1))
1678 cERROR(1, "Unexpected SMB signature");
1680 /* FIXME: should this be counted toward the initiating task? */
1681 task_io_account_read(rdata->bytes);
1682 cifs_stats_bytes_read(tcon, rdata->bytes);
1684 case MID_REQUEST_SUBMITTED:
1685 case MID_RETRY_NEEDED:
1686 rdata->result = -EAGAIN;
1689 rdata->result = -EIO;
1692 queue_work(cifsiod_wq, &rdata->work);
1693 DeleteMidQEntry(mid);
1694 cifs_add_credits(server, 1);
1697 /* cifs_async_readv - send an async write, and set up mid to handle result */
1699 cifs_async_readv(struct cifs_readdata *rdata)
1702 READ_REQ *smb = NULL;
1704 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1706 cFYI(1, "%s: offset=%llu bytes=%u", __func__,
1707 rdata->offset, rdata->bytes);
1709 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1712 wct = 10; /* old style read */
1713 if ((rdata->offset >> 32) > 0) {
1714 /* can not handle this big offset for old */
1719 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1723 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1724 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1726 smb->AndXCommand = 0xFF; /* none */
1727 smb->Fid = rdata->cfile->netfid;
1728 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1730 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1732 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1733 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1737 /* old style read */
1738 struct smb_com_readx_req *smbr =
1739 (struct smb_com_readx_req *)smb;
1740 smbr->ByteCount = 0;
1743 /* 4 for RFC1001 length + 1 for BCC */
1744 rdata->iov[0].iov_base = smb;
1745 rdata->iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1747 rc = cifs_call_async(tcon->ses->server, rdata->iov, 1,
1748 cifs_readv_receive, cifs_readv_callback,
1752 cifs_stats_inc(&tcon->num_reads);
1754 cifs_small_buf_release(smb);
1759 CIFSSMBRead(const int xid, struct cifs_io_parms *io_parms, unsigned int *nbytes,
1760 char **buf, int *pbuf_type)
1763 READ_REQ *pSMB = NULL;
1764 READ_RSP *pSMBr = NULL;
1765 char *pReadData = NULL;
1767 int resp_buf_type = 0;
1769 __u32 pid = io_parms->pid;
1770 __u16 netfid = io_parms->netfid;
1771 __u64 offset = io_parms->offset;
1772 struct cifs_tcon *tcon = io_parms->tcon;
1773 unsigned int count = io_parms->length;
1775 cFYI(1, "Reading %d bytes on fid %d", count, netfid);
1776 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1779 wct = 10; /* old style read */
1780 if ((offset >> 32) > 0) {
1781 /* can not handle this big offset for old */
1787 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1791 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1792 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1794 /* tcon and ses pointer are checked in smb_init */
1795 if (tcon->ses->server == NULL)
1796 return -ECONNABORTED;
1798 pSMB->AndXCommand = 0xFF; /* none */
1800 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1802 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1804 pSMB->Remaining = 0;
1805 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1806 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1808 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1810 /* old style read */
1811 struct smb_com_readx_req *pSMBW =
1812 (struct smb_com_readx_req *)pSMB;
1813 pSMBW->ByteCount = 0;
1816 iov[0].iov_base = (char *)pSMB;
1817 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1818 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1819 &resp_buf_type, CIFS_LOG_ERROR);
1820 cifs_stats_inc(&tcon->num_reads);
1821 pSMBr = (READ_RSP *)iov[0].iov_base;
1823 cERROR(1, "Send error in read = %d", rc);
1825 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1826 data_length = data_length << 16;
1827 data_length += le16_to_cpu(pSMBr->DataLength);
1828 *nbytes = data_length;
1830 /*check that DataLength would not go beyond end of SMB */
1831 if ((data_length > CIFSMaxBufSize)
1832 || (data_length > count)) {
1833 cFYI(1, "bad length %d for count %d",
1834 data_length, count);
1838 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1839 le16_to_cpu(pSMBr->DataOffset);
1840 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1841 cERROR(1, "Faulting on read rc = %d",rc);
1843 }*/ /* can not use copy_to_user when using page cache*/
1845 memcpy(*buf, pReadData, data_length);
1849 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1851 if (resp_buf_type == CIFS_SMALL_BUFFER)
1852 cifs_small_buf_release(iov[0].iov_base);
1853 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1854 cifs_buf_release(iov[0].iov_base);
1855 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1856 /* return buffer to caller to free */
1857 *buf = iov[0].iov_base;
1858 if (resp_buf_type == CIFS_SMALL_BUFFER)
1859 *pbuf_type = CIFS_SMALL_BUFFER;
1860 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1861 *pbuf_type = CIFS_LARGE_BUFFER;
1862 } /* else no valid buffer on return - leave as null */
1864 /* Note: On -EAGAIN error only caller can retry on handle based calls
1865 since file handle passed in no longer valid */
1871 CIFSSMBWrite(const int xid, struct cifs_io_parms *io_parms,
1872 unsigned int *nbytes, const char *buf,
1873 const char __user *ubuf, const int long_op)
1876 WRITE_REQ *pSMB = NULL;
1877 WRITE_RSP *pSMBr = NULL;
1878 int bytes_returned, wct;
1881 __u32 pid = io_parms->pid;
1882 __u16 netfid = io_parms->netfid;
1883 __u64 offset = io_parms->offset;
1884 struct cifs_tcon *tcon = io_parms->tcon;
1885 unsigned int count = io_parms->length;
1889 /* cFYI(1, "write at %lld %d bytes", offset, count);*/
1890 if (tcon->ses == NULL)
1891 return -ECONNABORTED;
1893 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1897 if ((offset >> 32) > 0) {
1898 /* can not handle big offset for old srv */
1903 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1908 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1909 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1911 /* tcon and ses pointer are checked in smb_init */
1912 if (tcon->ses->server == NULL)
1913 return -ECONNABORTED;
1915 pSMB->AndXCommand = 0xFF; /* none */
1917 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1919 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1921 pSMB->Reserved = 0xFFFFFFFF;
1922 pSMB->WriteMode = 0;
1923 pSMB->Remaining = 0;
1925 /* Can increase buffer size if buffer is big enough in some cases ie we
1926 can send more if LARGE_WRITE_X capability returned by the server and if
1927 our buffer is big enough or if we convert to iovecs on socket writes
1928 and eliminate the copy to the CIFS buffer */
1929 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1930 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1932 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1936 if (bytes_sent > count)
1939 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1941 memcpy(pSMB->Data, buf, bytes_sent);
1943 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1944 cifs_buf_release(pSMB);
1947 } else if (count != 0) {
1949 cifs_buf_release(pSMB);
1951 } /* else setting file size with write of zero bytes */
1953 byte_count = bytes_sent + 1; /* pad */
1954 else /* wct == 12 */
1955 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1957 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1958 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1959 inc_rfc1001_len(pSMB, byte_count);
1962 pSMB->ByteCount = cpu_to_le16(byte_count);
1963 else { /* old style write has byte count 4 bytes earlier
1965 struct smb_com_writex_req *pSMBW =
1966 (struct smb_com_writex_req *)pSMB;
1967 pSMBW->ByteCount = cpu_to_le16(byte_count);
1970 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1971 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1972 cifs_stats_inc(&tcon->num_writes);
1974 cFYI(1, "Send error in write = %d", rc);
1976 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1977 *nbytes = (*nbytes) << 16;
1978 *nbytes += le16_to_cpu(pSMBr->Count);
1981 * Mask off high 16 bits when bytes written as returned by the
1982 * server is greater than bytes requested by the client. Some
1983 * OS/2 servers are known to set incorrect CountHigh values.
1985 if (*nbytes > count)
1989 cifs_buf_release(pSMB);
1991 /* Note: On -EAGAIN error only caller can retry on handle based calls
1992 since file handle passed in no longer valid */
1998 cifs_writedata_release(struct kref *refcount)
2000 struct cifs_writedata *wdata = container_of(refcount,
2001 struct cifs_writedata, refcount);
2004 cifsFileInfo_put(wdata->cfile);
2010 * Write failed with a retryable error. Resend the write request. It's also
2011 * possible that the page was redirtied so re-clean the page.
2014 cifs_writev_requeue(struct cifs_writedata *wdata)
2017 struct inode *inode = wdata->cfile->dentry->d_inode;
2019 for (i = 0; i < wdata->nr_pages; i++) {
2020 lock_page(wdata->pages[i]);
2021 clear_page_dirty_for_io(wdata->pages[i]);
2025 rc = cifs_async_writev(wdata);
2026 } while (rc == -EAGAIN);
2028 for (i = 0; i < wdata->nr_pages; i++) {
2030 SetPageError(wdata->pages[i]);
2031 unlock_page(wdata->pages[i]);
2034 mapping_set_error(inode->i_mapping, rc);
2035 kref_put(&wdata->refcount, cifs_writedata_release);
2039 cifs_writev_complete(struct work_struct *work)
2041 struct cifs_writedata *wdata = container_of(work,
2042 struct cifs_writedata, work);
2043 struct inode *inode = wdata->cfile->dentry->d_inode;
2046 if (wdata->result == 0) {
2047 spin_lock(&inode->i_lock);
2048 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2049 spin_unlock(&inode->i_lock);
2050 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2052 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2053 return cifs_writev_requeue(wdata);
2055 for (i = 0; i < wdata->nr_pages; i++) {
2056 struct page *page = wdata->pages[i];
2057 if (wdata->result == -EAGAIN)
2058 __set_page_dirty_nobuffers(page);
2059 else if (wdata->result < 0)
2061 end_page_writeback(page);
2062 page_cache_release(page);
2064 if (wdata->result != -EAGAIN)
2065 mapping_set_error(inode->i_mapping, wdata->result);
2066 kref_put(&wdata->refcount, cifs_writedata_release);
2069 struct cifs_writedata *
2070 cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
2072 struct cifs_writedata *wdata;
2074 /* this would overflow */
2075 if (nr_pages == 0) {
2076 cERROR(1, "%s: called with nr_pages == 0!", __func__);
2080 /* writedata + number of page pointers */
2081 wdata = kzalloc(sizeof(*wdata) +
2082 sizeof(struct page *) * (nr_pages - 1), GFP_NOFS);
2083 if (wdata != NULL) {
2084 kref_init(&wdata->refcount);
2085 INIT_LIST_HEAD(&wdata->list);
2086 init_completion(&wdata->done);
2087 INIT_WORK(&wdata->work, complete);
2093 * Check the mid_state and signature on received buffer (if any), and queue the
2094 * workqueue completion task.
2097 cifs_writev_callback(struct mid_q_entry *mid)
2099 struct cifs_writedata *wdata = mid->callback_data;
2100 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2101 unsigned int written;
2102 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2104 switch (mid->mid_state) {
2105 case MID_RESPONSE_RECEIVED:
2106 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2107 if (wdata->result != 0)
2110 written = le16_to_cpu(smb->CountHigh);
2112 written += le16_to_cpu(smb->Count);
2114 * Mask off high 16 bits when bytes written as returned
2115 * by the server is greater than bytes requested by the
2116 * client. OS/2 servers are known to set incorrect
2119 if (written > wdata->bytes)
2122 if (written < wdata->bytes)
2123 wdata->result = -ENOSPC;
2125 wdata->bytes = written;
2127 case MID_REQUEST_SUBMITTED:
2128 case MID_RETRY_NEEDED:
2129 wdata->result = -EAGAIN;
2132 wdata->result = -EIO;
2136 queue_work(cifsiod_wq, &wdata->work);
2137 DeleteMidQEntry(mid);
2138 cifs_add_credits(tcon->ses->server, 1);
2141 /* cifs_async_writev - send an async write, and set up mid to handle result */
2143 cifs_async_writev(struct cifs_writedata *wdata)
2145 int i, rc = -EACCES;
2146 WRITE_REQ *smb = NULL;
2148 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2149 struct kvec *iov = NULL;
2151 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2155 if (wdata->offset >> 32 > 0) {
2156 /* can not handle big offset for old srv */
2161 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2163 goto async_writev_out;
2165 /* 1 iov per page + 1 for header */
2166 iov = kzalloc((wdata->nr_pages + 1) * sizeof(*iov), GFP_NOFS);
2169 goto async_writev_out;
2172 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2173 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
2175 smb->AndXCommand = 0xFF; /* none */
2176 smb->Fid = wdata->cfile->netfid;
2177 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2179 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2180 smb->Reserved = 0xFFFFFFFF;
2185 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2187 /* 4 for RFC1001 length + 1 for BCC */
2188 iov[0].iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2189 iov[0].iov_base = smb;
2192 * This function should marshal up the page array into the kvec
2193 * array, reserving [0] for the header. It should kmap the pages
2194 * and set the iov_len properly for each one. It may also set
2197 wdata->marshal_iov(iov, wdata);
2199 cFYI(1, "async write at %llu %u bytes", wdata->offset, wdata->bytes);
2201 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2202 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2205 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2206 put_bcc(wdata->bytes + 1, &smb->hdr);
2209 struct smb_com_writex_req *smbw =
2210 (struct smb_com_writex_req *)smb;
2211 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2212 put_bcc(wdata->bytes + 5, &smbw->hdr);
2213 iov[0].iov_len += 4; /* pad bigger by four bytes */
2216 kref_get(&wdata->refcount);
2217 rc = cifs_call_async(tcon->ses->server, iov, wdata->nr_pages + 1,
2218 NULL, cifs_writev_callback, wdata, false);
2221 cifs_stats_inc(&tcon->num_writes);
2223 kref_put(&wdata->refcount, cifs_writedata_release);
2225 /* send is done, unmap pages */
2226 for (i = 0; i < wdata->nr_pages; i++)
2227 kunmap(wdata->pages[i]);
2230 cifs_small_buf_release(smb);
2236 CIFSSMBWrite2(const int xid, struct cifs_io_parms *io_parms,
2237 unsigned int *nbytes, struct kvec *iov, int n_vec,
2241 WRITE_REQ *pSMB = NULL;
2244 int resp_buf_type = 0;
2245 __u32 pid = io_parms->pid;
2246 __u16 netfid = io_parms->netfid;
2247 __u64 offset = io_parms->offset;
2248 struct cifs_tcon *tcon = io_parms->tcon;
2249 unsigned int count = io_parms->length;
2253 cFYI(1, "write2 at %lld %d bytes", (long long)offset, count);
2255 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2259 if ((offset >> 32) > 0) {
2260 /* can not handle big offset for old srv */
2264 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
2268 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2269 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2271 /* tcon and ses pointer are checked in smb_init */
2272 if (tcon->ses->server == NULL)
2273 return -ECONNABORTED;
2275 pSMB->AndXCommand = 0xFF; /* none */
2277 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
2279 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
2280 pSMB->Reserved = 0xFFFFFFFF;
2281 pSMB->WriteMode = 0;
2282 pSMB->Remaining = 0;
2285 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2287 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2288 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
2289 /* header + 1 byte pad */
2290 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
2292 inc_rfc1001_len(pSMB, count + 1);
2293 else /* wct == 12 */
2294 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
2296 pSMB->ByteCount = cpu_to_le16(count + 1);
2297 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2298 struct smb_com_writex_req *pSMBW =
2299 (struct smb_com_writex_req *)pSMB;
2300 pSMBW->ByteCount = cpu_to_le16(count + 5);
2302 iov[0].iov_base = pSMB;
2304 iov[0].iov_len = smb_hdr_len + 4;
2305 else /* wct == 12 pad bigger by four bytes */
2306 iov[0].iov_len = smb_hdr_len + 8;
2309 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
2311 cifs_stats_inc(&tcon->num_writes);
2313 cFYI(1, "Send error Write2 = %d", rc);
2314 } else if (resp_buf_type == 0) {
2315 /* presumably this can not happen, but best to be safe */
2318 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
2319 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2320 *nbytes = (*nbytes) << 16;
2321 *nbytes += le16_to_cpu(pSMBr->Count);
2324 * Mask off high 16 bits when bytes written as returned by the
2325 * server is greater than bytes requested by the client. OS/2
2326 * servers are known to set incorrect CountHigh values.
2328 if (*nbytes > count)
2332 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2333 if (resp_buf_type == CIFS_SMALL_BUFFER)
2334 cifs_small_buf_release(iov[0].iov_base);
2335 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2336 cifs_buf_release(iov[0].iov_base);
2338 /* Note: On -EAGAIN error only caller can retry on handle based calls
2339 since file handle passed in no longer valid */
2344 int cifs_lockv(const int xid, struct cifs_tcon *tcon, const __u16 netfid,
2345 const __u8 lock_type, const __u32 num_unlock,
2346 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2349 LOCK_REQ *pSMB = NULL;
2354 cFYI(1, "cifs_lockv num lock %d num unlock %d", num_lock, num_unlock);
2356 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2361 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2362 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2363 pSMB->LockType = lock_type;
2364 pSMB->AndXCommand = 0xFF; /* none */
2365 pSMB->Fid = netfid; /* netfid stays le */
2367 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2368 inc_rfc1001_len(pSMB, count);
2369 pSMB->ByteCount = cpu_to_le16(count);
2371 iov[0].iov_base = (char *)pSMB;
2372 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2373 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2374 iov[1].iov_base = (char *)buf;
2375 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2377 cifs_stats_inc(&tcon->num_locks);
2378 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2380 cFYI(1, "Send error in cifs_lockv = %d", rc);
2386 CIFSSMBLock(const int xid, struct cifs_tcon *tcon,
2387 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
2388 const __u64 offset, const __u32 numUnlock,
2389 const __u32 numLock, const __u8 lockType,
2390 const bool waitFlag, const __u8 oplock_level)
2393 LOCK_REQ *pSMB = NULL;
2394 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2399 cFYI(1, "CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock);
2400 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2405 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
2406 timeout = CIFS_ASYNC_OP; /* no response expected */
2408 } else if (waitFlag) {
2409 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2410 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2415 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2416 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2417 pSMB->LockType = lockType;
2418 pSMB->OplockLevel = oplock_level;
2419 pSMB->AndXCommand = 0xFF; /* none */
2420 pSMB->Fid = smb_file_id; /* netfid stays le */
2422 if ((numLock != 0) || (numUnlock != 0)) {
2423 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
2424 /* BB where to store pid high? */
2425 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2426 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2427 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2428 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2429 count = sizeof(LOCKING_ANDX_RANGE);
2434 inc_rfc1001_len(pSMB, count);
2435 pSMB->ByteCount = cpu_to_le16(count);
2438 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2439 (struct smb_hdr *) pSMB, &bytes_returned);
2440 cifs_small_buf_release(pSMB);
2442 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, timeout);
2443 /* SMB buffer freed by function above */
2445 cifs_stats_inc(&tcon->num_locks);
2447 cFYI(1, "Send error in Lock = %d", rc);
2449 /* Note: On -EAGAIN error only caller can retry on handle based calls
2450 since file handle passed in no longer valid */
2455 CIFSSMBPosixLock(const int xid, struct cifs_tcon *tcon,
2456 const __u16 smb_file_id, const __u32 netpid, const int get_flag,
2457 const __u64 len, struct file_lock *pLockData,
2458 const __u16 lock_type, const bool waitFlag)
2460 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2461 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2462 struct cifs_posix_lock *parm_data;
2465 int bytes_returned = 0;
2466 int resp_buf_type = 0;
2467 __u16 params, param_offset, offset, byte_count, count;
2470 cFYI(1, "Posix Lock");
2472 if (pLockData == NULL)
2475 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2480 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2483 pSMB->MaxSetupCount = 0;
2486 pSMB->Reserved2 = 0;
2487 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2488 offset = param_offset + params;
2490 count = sizeof(struct cifs_posix_lock);
2491 pSMB->MaxParameterCount = cpu_to_le16(2);
2492 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2493 pSMB->SetupCount = 1;
2494 pSMB->Reserved3 = 0;
2496 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2498 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2499 byte_count = 3 /* pad */ + params + count;
2500 pSMB->DataCount = cpu_to_le16(count);
2501 pSMB->ParameterCount = cpu_to_le16(params);
2502 pSMB->TotalDataCount = pSMB->DataCount;
2503 pSMB->TotalParameterCount = pSMB->ParameterCount;
2504 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2505 parm_data = (struct cifs_posix_lock *)
2506 (((char *) &pSMB->hdr.Protocol) + offset);
2508 parm_data->lock_type = cpu_to_le16(lock_type);
2510 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2511 parm_data->lock_flags = cpu_to_le16(1);
2512 pSMB->Timeout = cpu_to_le32(-1);
2516 parm_data->pid = cpu_to_le32(netpid);
2517 parm_data->start = cpu_to_le64(pLockData->fl_start);
2518 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
2520 pSMB->DataOffset = cpu_to_le16(offset);
2521 pSMB->Fid = smb_file_id;
2522 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2523 pSMB->Reserved4 = 0;
2524 inc_rfc1001_len(pSMB, byte_count);
2525 pSMB->ByteCount = cpu_to_le16(byte_count);
2527 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2528 (struct smb_hdr *) pSMBr, &bytes_returned);
2530 iov[0].iov_base = (char *)pSMB;
2531 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2532 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2533 &resp_buf_type, timeout);
2534 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2535 not try to free it twice below on exit */
2536 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
2540 cFYI(1, "Send error in Posix Lock = %d", rc);
2541 } else if (get_flag) {
2542 /* lock structure can be returned on get */
2545 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2547 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2548 rc = -EIO; /* bad smb */
2551 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2552 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2553 if (data_count < sizeof(struct cifs_posix_lock)) {
2557 parm_data = (struct cifs_posix_lock *)
2558 ((char *)&pSMBr->hdr.Protocol + data_offset);
2559 if (parm_data->lock_type == __constant_cpu_to_le16(CIFS_UNLCK))
2560 pLockData->fl_type = F_UNLCK;
2562 if (parm_data->lock_type ==
2563 __constant_cpu_to_le16(CIFS_RDLCK))
2564 pLockData->fl_type = F_RDLCK;
2565 else if (parm_data->lock_type ==
2566 __constant_cpu_to_le16(CIFS_WRLCK))
2567 pLockData->fl_type = F_WRLCK;
2569 pLockData->fl_start = le64_to_cpu(parm_data->start);
2570 pLockData->fl_end = pLockData->fl_start +
2571 le64_to_cpu(parm_data->length) - 1;
2572 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
2578 cifs_small_buf_release(pSMB);
2580 if (resp_buf_type == CIFS_SMALL_BUFFER)
2581 cifs_small_buf_release(iov[0].iov_base);
2582 else if (resp_buf_type == CIFS_LARGE_BUFFER)
2583 cifs_buf_release(iov[0].iov_base);
2585 /* Note: On -EAGAIN error only caller can retry on handle based calls
2586 since file handle passed in no longer valid */
2593 CIFSSMBClose(const int xid, struct cifs_tcon *tcon, int smb_file_id)
2596 CLOSE_REQ *pSMB = NULL;
2597 cFYI(1, "In CIFSSMBClose");
2599 /* do not retry on dead session on close */
2600 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2606 pSMB->FileID = (__u16) smb_file_id;
2607 pSMB->LastWriteTime = 0xFFFFFFFF;
2608 pSMB->ByteCount = 0;
2609 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2610 cifs_stats_inc(&tcon->num_closes);
2613 /* EINTR is expected when user ctl-c to kill app */
2614 cERROR(1, "Send error in Close = %d", rc);
2618 /* Since session is dead, file will be closed on server already */
2626 CIFSSMBFlush(const int xid, struct cifs_tcon *tcon, int smb_file_id)
2629 FLUSH_REQ *pSMB = NULL;
2630 cFYI(1, "In CIFSSMBFlush");
2632 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2636 pSMB->FileID = (__u16) smb_file_id;
2637 pSMB->ByteCount = 0;
2638 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2639 cifs_stats_inc(&tcon->num_flushes);
2641 cERROR(1, "Send error in Flush = %d", rc);
2647 CIFSSMBRename(const int xid, struct cifs_tcon *tcon,
2648 const char *fromName, const char *toName,
2649 const struct nls_table *nls_codepage, int remap)
2652 RENAME_REQ *pSMB = NULL;
2653 RENAME_RSP *pSMBr = NULL;
2655 int name_len, name_len2;
2658 cFYI(1, "In CIFSSMBRename");
2660 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2665 pSMB->BufferFormat = 0x04;
2666 pSMB->SearchAttributes =
2667 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2670 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2672 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
2673 PATH_MAX, nls_codepage, remap);
2674 name_len++; /* trailing null */
2676 pSMB->OldFileName[name_len] = 0x04; /* pad */
2677 /* protocol requires ASCII signature byte on Unicode string */
2678 pSMB->OldFileName[name_len + 1] = 0x00;
2680 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2681 toName, PATH_MAX, nls_codepage, remap);
2682 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2683 name_len2 *= 2; /* convert to bytes */
2684 } else { /* BB improve the check for buffer overruns BB */
2685 name_len = strnlen(fromName, PATH_MAX);
2686 name_len++; /* trailing null */
2687 strncpy(pSMB->OldFileName, fromName, name_len);
2688 name_len2 = strnlen(toName, PATH_MAX);
2689 name_len2++; /* trailing null */
2690 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2691 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2692 name_len2++; /* trailing null */
2693 name_len2++; /* signature byte */
2696 count = 1 /* 1st signature byte */ + name_len + name_len2;
2697 inc_rfc1001_len(pSMB, count);
2698 pSMB->ByteCount = cpu_to_le16(count);
2700 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2701 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2702 cifs_stats_inc(&tcon->num_renames);
2704 cFYI(1, "Send error in rename = %d", rc);
2706 cifs_buf_release(pSMB);
2714 int CIFSSMBRenameOpenFile(const int xid, struct cifs_tcon *pTcon,
2715 int netfid, const char *target_name,
2716 const struct nls_table *nls_codepage, int remap)
2718 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2719 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2720 struct set_file_rename *rename_info;
2722 char dummy_string[30];
2724 int bytes_returned = 0;
2726 __u16 params, param_offset, offset, count, byte_count;
2728 cFYI(1, "Rename to File by handle");
2729 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2735 pSMB->MaxSetupCount = 0;
2739 pSMB->Reserved2 = 0;
2740 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2741 offset = param_offset + params;
2743 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2744 rename_info = (struct set_file_rename *) data_offset;
2745 pSMB->MaxParameterCount = cpu_to_le16(2);
2746 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2747 pSMB->SetupCount = 1;
2748 pSMB->Reserved3 = 0;
2749 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2750 byte_count = 3 /* pad */ + params;
2751 pSMB->ParameterCount = cpu_to_le16(params);
2752 pSMB->TotalParameterCount = pSMB->ParameterCount;
2753 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2754 pSMB->DataOffset = cpu_to_le16(offset);
2755 /* construct random name ".cifs_tmp<inodenum><mid>" */
2756 rename_info->overwrite = cpu_to_le32(1);
2757 rename_info->root_fid = 0;
2758 /* unicode only call */
2759 if (target_name == NULL) {
2760 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2762 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2763 dummy_string, 24, nls_codepage, remap);
2766 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2767 target_name, PATH_MAX, nls_codepage,
2770 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2771 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
2772 byte_count += count;
2773 pSMB->DataCount = cpu_to_le16(count);
2774 pSMB->TotalDataCount = pSMB->DataCount;
2776 pSMB->InformationLevel =
2777 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2778 pSMB->Reserved4 = 0;
2779 inc_rfc1001_len(pSMB, byte_count);
2780 pSMB->ByteCount = cpu_to_le16(byte_count);
2781 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2782 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2783 cifs_stats_inc(&pTcon->num_t2renames);
2785 cFYI(1, "Send error in Rename (by file handle) = %d", rc);
2787 cifs_buf_release(pSMB);
2789 /* Note: On -EAGAIN error only caller can retry on handle based calls
2790 since file handle passed in no longer valid */
2796 CIFSSMBCopy(const int xid, struct cifs_tcon *tcon, const char *fromName,
2797 const __u16 target_tid, const char *toName, const int flags,
2798 const struct nls_table *nls_codepage, int remap)
2801 COPY_REQ *pSMB = NULL;
2802 COPY_RSP *pSMBr = NULL;
2804 int name_len, name_len2;
2807 cFYI(1, "In CIFSSMBCopy");
2809 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2814 pSMB->BufferFormat = 0x04;
2815 pSMB->Tid2 = target_tid;
2817 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2819 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2820 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2821 fromName, PATH_MAX, nls_codepage,
2823 name_len++; /* trailing null */
2825 pSMB->OldFileName[name_len] = 0x04; /* pad */
2826 /* protocol requires ASCII signature byte on Unicode string */
2827 pSMB->OldFileName[name_len + 1] = 0x00;
2829 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2830 toName, PATH_MAX, nls_codepage, remap);
2831 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2832 name_len2 *= 2; /* convert to bytes */
2833 } else { /* BB improve the check for buffer overruns BB */
2834 name_len = strnlen(fromName, PATH_MAX);
2835 name_len++; /* trailing null */
2836 strncpy(pSMB->OldFileName, fromName, name_len);
2837 name_len2 = strnlen(toName, PATH_MAX);
2838 name_len2++; /* trailing null */
2839 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2840 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2841 name_len2++; /* trailing null */
2842 name_len2++; /* signature byte */
2845 count = 1 /* 1st signature byte */ + name_len + name_len2;
2846 inc_rfc1001_len(pSMB, count);
2847 pSMB->ByteCount = cpu_to_le16(count);
2849 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2850 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2852 cFYI(1, "Send error in copy = %d with %d files copied",
2853 rc, le16_to_cpu(pSMBr->CopyCount));
2855 cifs_buf_release(pSMB);
2864 CIFSUnixCreateSymLink(const int xid, struct cifs_tcon *tcon,
2865 const char *fromName, const char *toName,
2866 const struct nls_table *nls_codepage)
2868 TRANSACTION2_SPI_REQ *pSMB = NULL;
2869 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2872 int name_len_target;
2874 int bytes_returned = 0;
2875 __u16 params, param_offset, offset, byte_count;
2877 cFYI(1, "In Symlink Unix style");
2879 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2884 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2886 cifs_strtoUTF16((__le16 *) pSMB->FileName, fromName,
2887 /* find define for this maxpathcomponent */
2888 PATH_MAX, nls_codepage);
2889 name_len++; /* trailing null */
2892 } else { /* BB improve the check for buffer overruns BB */
2893 name_len = strnlen(fromName, PATH_MAX);
2894 name_len++; /* trailing null */
2895 strncpy(pSMB->FileName, fromName, name_len);
2897 params = 6 + name_len;
2898 pSMB->MaxSetupCount = 0;
2902 pSMB->Reserved2 = 0;
2903 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2904 InformationLevel) - 4;
2905 offset = param_offset + params;
2907 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2908 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2910 cifs_strtoUTF16((__le16 *) data_offset, toName, PATH_MAX
2911 /* find define for this maxpathcomponent */
2913 name_len_target++; /* trailing null */
2914 name_len_target *= 2;
2915 } else { /* BB improve the check for buffer overruns BB */
2916 name_len_target = strnlen(toName, PATH_MAX);
2917 name_len_target++; /* trailing null */
2918 strncpy(data_offset, toName, name_len_target);
2921 pSMB->MaxParameterCount = cpu_to_le16(2);
2922 /* BB find exact max on data count below from sess */
2923 pSMB->MaxDataCount = cpu_to_le16(1000);
2924 pSMB->SetupCount = 1;
2925 pSMB->Reserved3 = 0;
2926 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2927 byte_count = 3 /* pad */ + params + name_len_target;
2928 pSMB->DataCount = cpu_to_le16(name_len_target);
2929 pSMB->ParameterCount = cpu_to_le16(params);
2930 pSMB->TotalDataCount = pSMB->DataCount;
2931 pSMB->TotalParameterCount = pSMB->ParameterCount;
2932 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2933 pSMB->DataOffset = cpu_to_le16(offset);
2934 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2935 pSMB->Reserved4 = 0;
2936 inc_rfc1001_len(pSMB, byte_count);
2937 pSMB->ByteCount = cpu_to_le16(byte_count);
2938 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2939 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2940 cifs_stats_inc(&tcon->num_symlinks);
2942 cFYI(1, "Send error in SetPathInfo create symlink = %d", rc);
2944 cifs_buf_release(pSMB);
2947 goto createSymLinkRetry;
2953 CIFSUnixCreateHardLink(const int xid, struct cifs_tcon *tcon,
2954 const char *fromName, const char *toName,
2955 const struct nls_table *nls_codepage, int remap)
2957 TRANSACTION2_SPI_REQ *pSMB = NULL;
2958 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2961 int name_len_target;
2963 int bytes_returned = 0;
2964 __u16 params, param_offset, offset, byte_count;
2966 cFYI(1, "In Create Hard link Unix style");
2967 createHardLinkRetry:
2968 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2973 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2974 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2975 PATH_MAX, nls_codepage, remap);
2976 name_len++; /* trailing null */
2979 } else { /* BB improve the check for buffer overruns BB */
2980 name_len = strnlen(toName, PATH_MAX);
2981 name_len++; /* trailing null */
2982 strncpy(pSMB->FileName, toName, name_len);
2984 params = 6 + name_len;
2985 pSMB->MaxSetupCount = 0;
2989 pSMB->Reserved2 = 0;
2990 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2991 InformationLevel) - 4;
2992 offset = param_offset + params;
2994 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2995 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2997 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2998 PATH_MAX, nls_codepage, remap);
2999 name_len_target++; /* trailing null */
3000 name_len_target *= 2;
3001 } else { /* BB improve the check for buffer overruns BB */
3002 name_len_target = strnlen(fromName, PATH_MAX);
3003 name_len_target++; /* trailing null */
3004 strncpy(data_offset, fromName, name_len_target);
3007 pSMB->MaxParameterCount = cpu_to_le16(2);
3008 /* BB find exact max on data count below from sess*/
3009 pSMB->MaxDataCount = cpu_to_le16(1000);
3010 pSMB->SetupCount = 1;
3011 pSMB->Reserved3 = 0;
3012 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3013 byte_count = 3 /* pad */ + params + name_len_target;
3014 pSMB->ParameterCount = cpu_to_le16(params);
3015 pSMB->TotalParameterCount = pSMB->ParameterCount;
3016 pSMB->DataCount = cpu_to_le16(name_len_target);
3017 pSMB->TotalDataCount = pSMB->DataCount;
3018 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3019 pSMB->DataOffset = cpu_to_le16(offset);
3020 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
3021 pSMB->Reserved4 = 0;
3022 inc_rfc1001_len(pSMB, byte_count);
3023 pSMB->ByteCount = cpu_to_le16(byte_count);
3024 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3025 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3026 cifs_stats_inc(&tcon->num_hardlinks);
3028 cFYI(1, "Send error in SetPathInfo (hard link) = %d", rc);
3030 cifs_buf_release(pSMB);
3032 goto createHardLinkRetry;
3038 CIFSCreateHardLink(const int xid, struct cifs_tcon *tcon,
3039 const char *fromName, const char *toName,
3040 const struct nls_table *nls_codepage, int remap)
3043 NT_RENAME_REQ *pSMB = NULL;
3044 RENAME_RSP *pSMBr = NULL;
3046 int name_len, name_len2;
3049 cFYI(1, "In CIFSCreateHardLink");
3050 winCreateHardLinkRetry:
3052 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
3057 pSMB->SearchAttributes =
3058 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3060 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
3061 pSMB->ClusterCount = 0;
3063 pSMB->BufferFormat = 0x04;
3065 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3067 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, fromName,
3068 PATH_MAX, nls_codepage, remap);
3069 name_len++; /* trailing null */
3072 /* protocol specifies ASCII buffer format (0x04) for unicode */
3073 pSMB->OldFileName[name_len] = 0x04;
3074 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
3076 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3077 toName, PATH_MAX, nls_codepage, remap);
3078 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3079 name_len2 *= 2; /* convert to bytes */
3080 } else { /* BB improve the check for buffer overruns BB */
3081 name_len = strnlen(fromName, PATH_MAX);
3082 name_len++; /* trailing null */
3083 strncpy(pSMB->OldFileName, fromName, name_len);
3084 name_len2 = strnlen(toName, PATH_MAX);
3085 name_len2++; /* trailing null */
3086 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3087 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
3088 name_len2++; /* trailing null */
3089 name_len2++; /* signature byte */
3092 count = 1 /* string type byte */ + name_len + name_len2;
3093 inc_rfc1001_len(pSMB, count);
3094 pSMB->ByteCount = cpu_to_le16(count);
3096 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3097 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3098 cifs_stats_inc(&tcon->num_hardlinks);
3100 cFYI(1, "Send error in hard link (NT rename) = %d", rc);
3102 cifs_buf_release(pSMB);
3104 goto winCreateHardLinkRetry;
3110 CIFSSMBUnixQuerySymLink(const int xid, struct cifs_tcon *tcon,
3111 const unsigned char *searchName, char **symlinkinfo,
3112 const struct nls_table *nls_codepage)
3114 /* SMB_QUERY_FILE_UNIX_LINK */
3115 TRANSACTION2_QPI_REQ *pSMB = NULL;
3116 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3120 __u16 params, byte_count;
3123 cFYI(1, "In QPathSymLinkInfo (Unix) for path %s", searchName);
3126 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3131 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3133 cifs_strtoUTF16((__le16 *) pSMB->FileName, searchName,
3134 PATH_MAX, nls_codepage);
3135 name_len++; /* trailing null */
3137 } else { /* BB improve the check for buffer overruns BB */
3138 name_len = strnlen(searchName, PATH_MAX);
3139 name_len++; /* trailing null */
3140 strncpy(pSMB->FileName, searchName, name_len);
3143 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3144 pSMB->TotalDataCount = 0;
3145 pSMB->MaxParameterCount = cpu_to_le16(2);
3146 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3147 pSMB->MaxSetupCount = 0;
3151 pSMB->Reserved2 = 0;
3152 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3153 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3154 pSMB->DataCount = 0;
3155 pSMB->DataOffset = 0;
3156 pSMB->SetupCount = 1;
3157 pSMB->Reserved3 = 0;
3158 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3159 byte_count = params + 1 /* pad */ ;
3160 pSMB->TotalParameterCount = cpu_to_le16(params);
3161 pSMB->ParameterCount = pSMB->TotalParameterCount;
3162 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3163 pSMB->Reserved4 = 0;
3164 inc_rfc1001_len(pSMB, byte_count);
3165 pSMB->ByteCount = cpu_to_le16(byte_count);
3167 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3168 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3170 cFYI(1, "Send error in QuerySymLinkInfo = %d", rc);
3172 /* decode response */
3174 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3175 /* BB also check enough total bytes returned */
3176 if (rc || get_bcc(&pSMBr->hdr) < 2)
3180 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3182 data_start = ((char *) &pSMBr->hdr.Protocol) +
3183 le16_to_cpu(pSMBr->t2.DataOffset);
3185 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3190 /* BB FIXME investigate remapping reserved chars here */
3191 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3192 count, is_unicode, nls_codepage);
3197 cifs_buf_release(pSMB);
3199 goto querySymLinkRetry;
3203 #ifdef CONFIG_CIFS_SYMLINK_EXPERIMENTAL
3205 * Recent Windows versions now create symlinks more frequently
3206 * and they use the "reparse point" mechanism below. We can of course
3207 * do symlinks nicely to Samba and other servers which support the
3208 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3209 * "MF" symlinks optionally, but for recent Windows we really need to
3210 * reenable the code below and fix the cifs_symlink callers to handle this.
3211 * In the interim this code has been moved to its own config option so
3212 * it is not compiled in by default until callers fixed up and more tested.
3215 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifs_tcon *tcon,
3216 const unsigned char *searchName,
3217 char *symlinkinfo, const int buflen, __u16 fid,
3218 const struct nls_table *nls_codepage)
3222 struct smb_com_transaction_ioctl_req *pSMB;
3223 struct smb_com_transaction_ioctl_rsp *pSMBr;
3225 cFYI(1, "In Windows reparse style QueryLink for path %s", searchName);
3226 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3231 pSMB->TotalParameterCount = 0 ;
3232 pSMB->TotalDataCount = 0;
3233 pSMB->MaxParameterCount = cpu_to_le32(2);
3234 /* BB find exact data count max from sess structure BB */
3235 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3236 pSMB->MaxSetupCount = 4;
3238 pSMB->ParameterOffset = 0;
3239 pSMB->DataCount = 0;
3240 pSMB->DataOffset = 0;
3241 pSMB->SetupCount = 4;
3242 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3243 pSMB->ParameterCount = pSMB->TotalParameterCount;
3244 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3245 pSMB->IsFsctl = 1; /* FSCTL */
3246 pSMB->IsRootFlag = 0;
3247 pSMB->Fid = fid; /* file handle always le */
3248 pSMB->ByteCount = 0;
3250 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3251 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3253 cFYI(1, "Send error in QueryReparseLinkInfo = %d", rc);
3254 } else { /* decode response */
3255 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
3256 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
3257 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3258 /* BB also check enough total bytes returned */
3259 rc = -EIO; /* bad smb */
3262 if (data_count && (data_count < 2048)) {
3263 char *end_of_smb = 2 /* sizeof byte count */ +
3264 get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
3266 struct reparse_data *reparse_buf =
3267 (struct reparse_data *)
3268 ((char *)&pSMBr->hdr.Protocol
3270 if ((char *)reparse_buf >= end_of_smb) {
3274 if ((reparse_buf->LinkNamesBuf +
3275 reparse_buf->TargetNameOffset +
3276 reparse_buf->TargetNameLen) > end_of_smb) {
3277 cFYI(1, "reparse buf beyond SMB");
3282 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3283 cifs_from_ucs2(symlinkinfo, (__le16 *)
3284 (reparse_buf->LinkNamesBuf +
3285 reparse_buf->TargetNameOffset),
3287 reparse_buf->TargetNameLen,
3289 } else { /* ASCII names */
3290 strncpy(symlinkinfo,
3291 reparse_buf->LinkNamesBuf +
3292 reparse_buf->TargetNameOffset,
3293 min_t(const int, buflen,
3294 reparse_buf->TargetNameLen));
3298 cFYI(1, "Invalid return data count on "
3299 "get reparse info ioctl");
3301 symlinkinfo[buflen] = 0; /* just in case so the caller
3302 does not go off the end of the buffer */
3303 cFYI(1, "readlink result - %s", symlinkinfo);
3307 cifs_buf_release(pSMB);
3309 /* Note: On -EAGAIN error only caller can retry on handle based calls
3310 since file handle passed in no longer valid */
3314 #endif /* CIFS_SYMLINK_EXPERIMENTAL */ /* BB temporarily unused */
3316 #ifdef CONFIG_CIFS_POSIX
3318 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3319 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3320 struct cifs_posix_ace *cifs_ace)
3322 /* u8 cifs fields do not need le conversion */
3323 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3324 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3325 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
3326 /* cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id); */
3331 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3332 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3333 const int acl_type, const int size_of_data_area)
3338 struct cifs_posix_ace *pACE;
3339 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3340 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
3342 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3345 if (acl_type & ACL_TYPE_ACCESS) {
3346 count = le16_to_cpu(cifs_acl->access_entry_count);
3347 pACE = &cifs_acl->ace_array[0];
3348 size = sizeof(struct cifs_posix_acl);
3349 size += sizeof(struct cifs_posix_ace) * count;
3350 /* check if we would go beyond end of SMB */
3351 if (size_of_data_area < size) {
3352 cFYI(1, "bad CIFS POSIX ACL size %d vs. %d",
3353 size_of_data_area, size);
3356 } else if (acl_type & ACL_TYPE_DEFAULT) {
3357 count = le16_to_cpu(cifs_acl->access_entry_count);
3358 size = sizeof(struct cifs_posix_acl);
3359 size += sizeof(struct cifs_posix_ace) * count;
3360 /* skip past access ACEs to get to default ACEs */
3361 pACE = &cifs_acl->ace_array[count];
3362 count = le16_to_cpu(cifs_acl->default_entry_count);
3363 size += sizeof(struct cifs_posix_ace) * count;
3364 /* check if we would go beyond end of SMB */
3365 if (size_of_data_area < size)
3372 size = posix_acl_xattr_size(count);
3373 if ((buflen == 0) || (local_acl == NULL)) {
3374 /* used to query ACL EA size */
3375 } else if (size > buflen) {
3377 } else /* buffer big enough */ {
3378 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
3379 for (i = 0; i < count ; i++) {
3380 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3387 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3388 const posix_acl_xattr_entry *local_ace)
3390 __u16 rc = 0; /* 0 = ACL converted ok */
3392 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3393 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
3394 /* BB is there a better way to handle the large uid? */
3395 if (local_ace->e_id == cpu_to_le32(-1)) {
3396 /* Probably no need to le convert -1 on any arch but can not hurt */
3397 cifs_ace->cifs_uid = cpu_to_le64(-1);
3399 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
3400 /*cFYI(1, "perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id);*/
3404 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3405 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3406 const int buflen, const int acl_type)
3409 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3410 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
3414 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
3417 count = posix_acl_xattr_count((size_t)buflen);
3418 cFYI(1, "setting acl with %d entries from buf of length %d and "
3420 count, buflen, le32_to_cpu(local_acl->a_version));
3421 if (le32_to_cpu(local_acl->a_version) != 2) {
3422 cFYI(1, "unknown POSIX ACL version %d",
3423 le32_to_cpu(local_acl->a_version));
3426 cifs_acl->version = cpu_to_le16(1);
3427 if (acl_type == ACL_TYPE_ACCESS)
3428 cifs_acl->access_entry_count = cpu_to_le16(count);
3429 else if (acl_type == ACL_TYPE_DEFAULT)
3430 cifs_acl->default_entry_count = cpu_to_le16(count);
3432 cFYI(1, "unknown ACL type %d", acl_type);
3435 for (i = 0; i < count; i++) {
3436 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3437 &local_acl->a_entries[i]);
3439 /* ACE not converted */
3444 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3445 rc += sizeof(struct cifs_posix_acl);
3446 /* BB add check to make sure ACL does not overflow SMB */
3452 CIFSSMBGetPosixACL(const int xid, struct cifs_tcon *tcon,
3453 const unsigned char *searchName,
3454 char *acl_inf, const int buflen, const int acl_type,
3455 const struct nls_table *nls_codepage, int remap)
3457 /* SMB_QUERY_POSIX_ACL */
3458 TRANSACTION2_QPI_REQ *pSMB = NULL;
3459 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3463 __u16 params, byte_count;
3465 cFYI(1, "In GetPosixACL (Unix) for path %s", searchName);
3468 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3473 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3475 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3476 searchName, PATH_MAX, nls_codepage,
3478 name_len++; /* trailing null */
3480 pSMB->FileName[name_len] = 0;
3481 pSMB->FileName[name_len+1] = 0;
3482 } else { /* BB improve the check for buffer overruns BB */
3483 name_len = strnlen(searchName, PATH_MAX);
3484 name_len++; /* trailing null */
3485 strncpy(pSMB->FileName, searchName, name_len);
3488 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3489 pSMB->TotalDataCount = 0;
3490 pSMB->MaxParameterCount = cpu_to_le16(2);
3491 /* BB find exact max data count below from sess structure BB */
3492 pSMB->MaxDataCount = cpu_to_le16(4000);
3493 pSMB->MaxSetupCount = 0;
3497 pSMB->Reserved2 = 0;
3498 pSMB->ParameterOffset = cpu_to_le16(
3499 offsetof(struct smb_com_transaction2_qpi_req,
3500 InformationLevel) - 4);
3501 pSMB->DataCount = 0;
3502 pSMB->DataOffset = 0;
3503 pSMB->SetupCount = 1;
3504 pSMB->Reserved3 = 0;
3505 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3506 byte_count = params + 1 /* pad */ ;
3507 pSMB->TotalParameterCount = cpu_to_le16(params);
3508 pSMB->ParameterCount = pSMB->TotalParameterCount;
3509 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3510 pSMB->Reserved4 = 0;
3511 inc_rfc1001_len(pSMB, byte_count);
3512 pSMB->ByteCount = cpu_to_le16(byte_count);
3514 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3515 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3516 cifs_stats_inc(&tcon->num_acl_get);
3518 cFYI(1, "Send error in Query POSIX ACL = %d", rc);
3520 /* decode response */
3522 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3523 /* BB also check enough total bytes returned */
3524 if (rc || get_bcc(&pSMBr->hdr) < 2)
3525 rc = -EIO; /* bad smb */
3527 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3528 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3529 rc = cifs_copy_posix_acl(acl_inf,
3530 (char *)&pSMBr->hdr.Protocol+data_offset,
3531 buflen, acl_type, count);
3534 cifs_buf_release(pSMB);
3541 CIFSSMBSetPosixACL(const int xid, struct cifs_tcon *tcon,
3542 const unsigned char *fileName,
3543 const char *local_acl, const int buflen,
3545 const struct nls_table *nls_codepage, int remap)
3547 struct smb_com_transaction2_spi_req *pSMB = NULL;
3548 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3552 int bytes_returned = 0;
3553 __u16 params, byte_count, data_count, param_offset, offset;
3555 cFYI(1, "In SetPosixACL (Unix) for path %s", fileName);
3557 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3561 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3563 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3564 PATH_MAX, nls_codepage, remap);
3565 name_len++; /* trailing null */
3567 } else { /* BB improve the check for buffer overruns BB */
3568 name_len = strnlen(fileName, PATH_MAX);
3569 name_len++; /* trailing null */
3570 strncpy(pSMB->FileName, fileName, name_len);
3572 params = 6 + name_len;
3573 pSMB->MaxParameterCount = cpu_to_le16(2);
3574 /* BB find max SMB size from sess */
3575 pSMB->MaxDataCount = cpu_to_le16(1000);
3576 pSMB->MaxSetupCount = 0;
3580 pSMB->Reserved2 = 0;
3581 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3582 InformationLevel) - 4;
3583 offset = param_offset + params;
3584 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3585 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3587 /* convert to on the wire format for POSIX ACL */
3588 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
3590 if (data_count == 0) {
3592 goto setACLerrorExit;
3594 pSMB->DataOffset = cpu_to_le16(offset);
3595 pSMB->SetupCount = 1;
3596 pSMB->Reserved3 = 0;
3597 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3598 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3599 byte_count = 3 /* pad */ + params + data_count;
3600 pSMB->DataCount = cpu_to_le16(data_count);
3601 pSMB->TotalDataCount = pSMB->DataCount;
3602 pSMB->ParameterCount = cpu_to_le16(params);
3603 pSMB->TotalParameterCount = pSMB->ParameterCount;
3604 pSMB->Reserved4 = 0;
3605 inc_rfc1001_len(pSMB, byte_count);
3606 pSMB->ByteCount = cpu_to_le16(byte_count);
3607 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3608 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3610 cFYI(1, "Set POSIX ACL returned %d", rc);
3613 cifs_buf_release(pSMB);
3619 /* BB fix tabs in this function FIXME BB */
3621 CIFSGetExtAttr(const int xid, struct cifs_tcon *tcon,
3622 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3625 struct smb_t2_qfi_req *pSMB = NULL;
3626 struct smb_t2_qfi_rsp *pSMBr = NULL;
3628 __u16 params, byte_count;
3630 cFYI(1, "In GetExtAttr");
3635 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3640 params = 2 /* level */ + 2 /* fid */;
3641 pSMB->t2.TotalDataCount = 0;
3642 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3643 /* BB find exact max data count below from sess structure BB */
3644 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3645 pSMB->t2.MaxSetupCount = 0;
3646 pSMB->t2.Reserved = 0;
3648 pSMB->t2.Timeout = 0;
3649 pSMB->t2.Reserved2 = 0;
3650 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3652 pSMB->t2.DataCount = 0;
3653 pSMB->t2.DataOffset = 0;
3654 pSMB->t2.SetupCount = 1;
3655 pSMB->t2.Reserved3 = 0;
3656 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3657 byte_count = params + 1 /* pad */ ;
3658 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3659 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3660 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3663 inc_rfc1001_len(pSMB, byte_count);
3664 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3666 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3667 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3669 cFYI(1, "error %d in GetExtAttr", rc);
3671 /* decode response */
3672 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3673 /* BB also check enough total bytes returned */
3674 if (rc || get_bcc(&pSMBr->hdr) < 2)
3675 /* If rc should we check for EOPNOSUPP and
3676 disable the srvino flag? or in caller? */
3677 rc = -EIO; /* bad smb */
3679 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3680 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3681 struct file_chattr_info *pfinfo;
3682 /* BB Do we need a cast or hash here ? */
3684 cFYI(1, "Illegal size ret in GetExtAttr");
3688 pfinfo = (struct file_chattr_info *)
3689 (data_offset + (char *) &pSMBr->hdr.Protocol);
3690 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3691 *pMask = le64_to_cpu(pfinfo->mask);
3695 cifs_buf_release(pSMB);
3697 goto GetExtAttrRetry;
3701 #endif /* CONFIG_POSIX */
3703 #ifdef CONFIG_CIFS_ACL
3705 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3706 * all NT TRANSACTS that we init here have total parm and data under about 400
3707 * bytes (to fit in small cifs buffer size), which is the case so far, it
3708 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3709 * returned setup area) and MaxParameterCount (returned parms size) must be set
3713 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3714 const int parm_len, struct cifs_tcon *tcon,
3719 struct smb_com_ntransact_req *pSMB;
3721 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3725 *ret_buf = (void *)pSMB;
3727 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3728 pSMB->TotalDataCount = 0;
3729 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3730 pSMB->ParameterCount = pSMB->TotalParameterCount;
3731 pSMB->DataCount = pSMB->TotalDataCount;
3732 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3733 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3734 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3735 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3736 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3737 pSMB->SubCommand = cpu_to_le16(sub_command);
3742 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3743 __u32 *pparmlen, __u32 *pdatalen)
3746 __u32 data_count, data_offset, parm_count, parm_offset;
3747 struct smb_com_ntransact_rsp *pSMBr;
3756 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3758 bcc = get_bcc(&pSMBr->hdr);
3759 end_of_smb = 2 /* sizeof byte count */ + bcc +
3760 (char *)&pSMBr->ByteCount;
3762 data_offset = le32_to_cpu(pSMBr->DataOffset);
3763 data_count = le32_to_cpu(pSMBr->DataCount);
3764 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3765 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3767 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3768 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3770 /* should we also check that parm and data areas do not overlap? */
3771 if (*ppparm > end_of_smb) {
3772 cFYI(1, "parms start after end of smb");
3774 } else if (parm_count + *ppparm > end_of_smb) {
3775 cFYI(1, "parm end after end of smb");
3777 } else if (*ppdata > end_of_smb) {
3778 cFYI(1, "data starts after end of smb");
3780 } else if (data_count + *ppdata > end_of_smb) {
3781 cFYI(1, "data %p + count %d (%p) past smb end %p start %p",
3782 *ppdata, data_count, (data_count + *ppdata),
3785 } else if (parm_count + data_count > bcc) {
3786 cFYI(1, "parm count and data count larger than SMB");
3789 *pdatalen = data_count;
3790 *pparmlen = parm_count;
3794 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3796 CIFSSMBGetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
3797 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3801 QUERY_SEC_DESC_REQ *pSMB;
3804 cFYI(1, "GetCifsACL");
3809 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3810 8 /* parm len */, tcon, (void **) &pSMB);
3814 pSMB->MaxParameterCount = cpu_to_le32(4);
3815 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3816 pSMB->MaxSetupCount = 0;
3817 pSMB->Fid = fid; /* file handle always le */
3818 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3820 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3821 inc_rfc1001_len(pSMB, 11);
3822 iov[0].iov_base = (char *)pSMB;
3823 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3825 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3827 cifs_stats_inc(&tcon->num_acl_get);
3829 cFYI(1, "Send error in QuerySecDesc = %d", rc);
3830 } else { /* decode response */
3834 struct smb_com_ntransact_rsp *pSMBr;
3837 /* validate_nttransact */
3838 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3839 &pdata, &parm_len, pbuflen);
3842 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3844 cFYI(1, "smb %p parm %p data %p", pSMBr, parm, *acl_inf);
3846 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3847 rc = -EIO; /* bad smb */
3852 /* BB check that data area is minimum length and as big as acl_len */
3854 acl_len = le32_to_cpu(*parm);
3855 if (acl_len != *pbuflen) {
3856 cERROR(1, "acl length %d does not match %d",
3858 if (*pbuflen > acl_len)
3862 /* check if buffer is big enough for the acl
3863 header followed by the smallest SID */
3864 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3865 (*pbuflen >= 64 * 1024)) {
3866 cERROR(1, "bad acl length %d", *pbuflen);
3870 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3871 if (*acl_inf == NULL) {
3875 memcpy(*acl_inf, pdata, *pbuflen);
3879 if (buf_type == CIFS_SMALL_BUFFER)
3880 cifs_small_buf_release(iov[0].iov_base);
3881 else if (buf_type == CIFS_LARGE_BUFFER)
3882 cifs_buf_release(iov[0].iov_base);
3883 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3888 CIFSSMBSetCIFSACL(const int xid, struct cifs_tcon *tcon, __u16 fid,
3889 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3891 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3893 int bytes_returned = 0;
3894 SET_SEC_DESC_REQ *pSMB = NULL;
3895 NTRANSACT_RSP *pSMBr = NULL;
3898 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3903 pSMB->MaxSetupCount = 0;
3907 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3908 data_count = acllen;
3909 data_offset = param_offset + param_count;
3910 byte_count = 3 /* pad */ + param_count;
3912 pSMB->DataCount = cpu_to_le32(data_count);
3913 pSMB->TotalDataCount = pSMB->DataCount;
3914 pSMB->MaxParameterCount = cpu_to_le32(4);
3915 pSMB->MaxDataCount = cpu_to_le32(16384);
3916 pSMB->ParameterCount = cpu_to_le32(param_count);
3917 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3918 pSMB->TotalParameterCount = pSMB->ParameterCount;
3919 pSMB->DataOffset = cpu_to_le32(data_offset);
3920 pSMB->SetupCount = 0;
3921 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3922 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3924 pSMB->Fid = fid; /* file handle always le */
3925 pSMB->Reserved2 = 0;
3926 pSMB->AclFlags = cpu_to_le32(aclflag);
3928 if (pntsd && acllen) {
3929 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3932 inc_rfc1001_len(pSMB, byte_count + data_count);
3934 inc_rfc1001_len(pSMB, byte_count);
3936 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3937 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3939 cFYI(1, "SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc);
3941 cFYI(1, "Set CIFS ACL returned %d", rc);
3942 cifs_buf_release(pSMB);
3945 goto setCifsAclRetry;
3950 #endif /* CONFIG_CIFS_ACL */
3952 /* Legacy Query Path Information call for lookup to old servers such
3954 int SMBQueryInformation(const int xid, struct cifs_tcon *tcon,
3955 const unsigned char *searchName,
3956 FILE_ALL_INFO *pFinfo,
3957 const struct nls_table *nls_codepage, int remap)
3959 QUERY_INFORMATION_REQ *pSMB;
3960 QUERY_INFORMATION_RSP *pSMBr;
3965 cFYI(1, "In SMBQPath path %s", searchName);
3967 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3972 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3974 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3975 searchName, PATH_MAX, nls_codepage,
3977 name_len++; /* trailing null */
3980 name_len = strnlen(searchName, PATH_MAX);
3981 name_len++; /* trailing null */
3982 strncpy(pSMB->FileName, searchName, name_len);
3984 pSMB->BufferFormat = 0x04;
3985 name_len++; /* account for buffer type byte */
3986 inc_rfc1001_len(pSMB, (__u16)name_len);
3987 pSMB->ByteCount = cpu_to_le16(name_len);
3989 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3990 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3992 cFYI(1, "Send error in QueryInfo = %d", rc);
3993 } else if (pFinfo) {
3995 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3997 /* decode response */
3998 /* BB FIXME - add time zone adjustment BB */
3999 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
4002 /* decode time fields */
4003 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
4004 pFinfo->LastWriteTime = pFinfo->ChangeTime;
4005 pFinfo->LastAccessTime = 0;
4006 pFinfo->AllocationSize =
4007 cpu_to_le64(le32_to_cpu(pSMBr->size));
4008 pFinfo->EndOfFile = pFinfo->AllocationSize;
4009 pFinfo->Attributes =
4010 cpu_to_le32(le16_to_cpu(pSMBr->attr));
4012 rc = -EIO; /* bad buffer passed in */
4014 cifs_buf_release(pSMB);
4023 CIFSSMBQFileInfo(const int xid, struct cifs_tcon *tcon,
4024 u16 netfid, FILE_ALL_INFO *pFindData)
4026 struct smb_t2_qfi_req *pSMB = NULL;
4027 struct smb_t2_qfi_rsp *pSMBr = NULL;
4030 __u16 params, byte_count;
4033 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4038 params = 2 /* level */ + 2 /* fid */;
4039 pSMB->t2.TotalDataCount = 0;
4040 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4041 /* BB find exact max data count below from sess structure BB */
4042 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4043 pSMB->t2.MaxSetupCount = 0;
4044 pSMB->t2.Reserved = 0;
4046 pSMB->t2.Timeout = 0;
4047 pSMB->t2.Reserved2 = 0;
4048 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4050 pSMB->t2.DataCount = 0;
4051 pSMB->t2.DataOffset = 0;
4052 pSMB->t2.SetupCount = 1;
4053 pSMB->t2.Reserved3 = 0;
4054 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4055 byte_count = params + 1 /* pad */ ;
4056 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4057 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4058 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4061 inc_rfc1001_len(pSMB, byte_count);
4063 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4064 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4066 cFYI(1, "Send error in QPathInfo = %d", rc);
4067 } else { /* decode response */
4068 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4070 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4072 else if (get_bcc(&pSMBr->hdr) < 40)
4073 rc = -EIO; /* bad smb */
4074 else if (pFindData) {
4075 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4076 memcpy((char *) pFindData,
4077 (char *) &pSMBr->hdr.Protocol +
4078 data_offset, sizeof(FILE_ALL_INFO));
4082 cifs_buf_release(pSMB);
4084 goto QFileInfoRetry;
4090 CIFSSMBQPathInfo(const int xid, struct cifs_tcon *tcon,
4091 const unsigned char *searchName,
4092 FILE_ALL_INFO *pFindData,
4093 int legacy /* old style infolevel */,
4094 const struct nls_table *nls_codepage, int remap)
4096 /* level 263 SMB_QUERY_FILE_ALL_INFO */
4097 TRANSACTION2_QPI_REQ *pSMB = NULL;
4098 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4102 __u16 params, byte_count;
4104 /* cFYI(1, "In QPathInfo path %s", searchName); */
4106 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4111 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4113 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4114 PATH_MAX, nls_codepage, remap);
4115 name_len++; /* trailing null */
4117 } else { /* BB improve the check for buffer overruns BB */
4118 name_len = strnlen(searchName, PATH_MAX);
4119 name_len++; /* trailing null */
4120 strncpy(pSMB->FileName, searchName, name_len);
4123 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4124 pSMB->TotalDataCount = 0;
4125 pSMB->MaxParameterCount = cpu_to_le16(2);
4126 /* BB find exact max SMB PDU from sess structure BB */
4127 pSMB->MaxDataCount = cpu_to_le16(4000);
4128 pSMB->MaxSetupCount = 0;
4132 pSMB->Reserved2 = 0;
4133 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4134 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4135 pSMB->DataCount = 0;
4136 pSMB->DataOffset = 0;
4137 pSMB->SetupCount = 1;
4138 pSMB->Reserved3 = 0;
4139 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4140 byte_count = params + 1 /* pad */ ;
4141 pSMB->TotalParameterCount = cpu_to_le16(params);
4142 pSMB->ParameterCount = pSMB->TotalParameterCount;
4144 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4146 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4147 pSMB->Reserved4 = 0;
4148 inc_rfc1001_len(pSMB, byte_count);
4149 pSMB->ByteCount = cpu_to_le16(byte_count);
4151 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4152 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4154 cFYI(1, "Send error in QPathInfo = %d", rc);
4155 } else { /* decode response */
4156 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4158 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4160 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
4161 rc = -EIO; /* bad smb */
4162 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
4163 rc = -EIO; /* 24 or 26 expected but we do not read
4165 else if (pFindData) {
4167 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4169 /* On legacy responses we do not read the last field,
4170 EAsize, fortunately since it varies by subdialect and
4171 also note it differs on Set vs. Get, ie two bytes or 4
4172 bytes depending but we don't care here */
4174 size = sizeof(FILE_INFO_STANDARD);
4176 size = sizeof(FILE_ALL_INFO);
4177 memcpy((char *) pFindData,
4178 (char *) &pSMBr->hdr.Protocol +
4183 cifs_buf_release(pSMB);
4185 goto QPathInfoRetry;
4191 CIFSSMBUnixQFileInfo(const int xid, struct cifs_tcon *tcon,
4192 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4194 struct smb_t2_qfi_req *pSMB = NULL;
4195 struct smb_t2_qfi_rsp *pSMBr = NULL;
4198 __u16 params, byte_count;
4201 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4206 params = 2 /* level */ + 2 /* fid */;
4207 pSMB->t2.TotalDataCount = 0;
4208 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4209 /* BB find exact max data count below from sess structure BB */
4210 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4211 pSMB->t2.MaxSetupCount = 0;
4212 pSMB->t2.Reserved = 0;
4214 pSMB->t2.Timeout = 0;
4215 pSMB->t2.Reserved2 = 0;
4216 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4218 pSMB->t2.DataCount = 0;
4219 pSMB->t2.DataOffset = 0;
4220 pSMB->t2.SetupCount = 1;
4221 pSMB->t2.Reserved3 = 0;
4222 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4223 byte_count = params + 1 /* pad */ ;
4224 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4225 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4226 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4229 inc_rfc1001_len(pSMB, byte_count);
4231 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4232 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4234 cFYI(1, "Send error in QPathInfo = %d", rc);
4235 } else { /* decode response */
4236 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4238 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4239 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
4240 "Unix Extensions can be disabled on mount "
4241 "by specifying the nosfu mount option.");
4242 rc = -EIO; /* bad smb */
4244 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4245 memcpy((char *) pFindData,
4246 (char *) &pSMBr->hdr.Protocol +
4248 sizeof(FILE_UNIX_BASIC_INFO));
4252 cifs_buf_release(pSMB);
4254 goto UnixQFileInfoRetry;
4260 CIFSSMBUnixQPathInfo(const int xid, struct cifs_tcon *tcon,
4261 const unsigned char *searchName,
4262 FILE_UNIX_BASIC_INFO *pFindData,
4263 const struct nls_table *nls_codepage, int remap)
4265 /* SMB_QUERY_FILE_UNIX_BASIC */
4266 TRANSACTION2_QPI_REQ *pSMB = NULL;
4267 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4269 int bytes_returned = 0;
4271 __u16 params, byte_count;
4273 cFYI(1, "In QPathInfo (Unix) the path %s", searchName);
4275 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4280 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4282 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4283 PATH_MAX, nls_codepage, remap);
4284 name_len++; /* trailing null */
4286 } else { /* BB improve the check for buffer overruns BB */
4287 name_len = strnlen(searchName, PATH_MAX);
4288 name_len++; /* trailing null */
4289 strncpy(pSMB->FileName, searchName, name_len);
4292 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4293 pSMB->TotalDataCount = 0;
4294 pSMB->MaxParameterCount = cpu_to_le16(2);
4295 /* BB find exact max SMB PDU from sess structure BB */
4296 pSMB->MaxDataCount = cpu_to_le16(4000);
4297 pSMB->MaxSetupCount = 0;
4301 pSMB->Reserved2 = 0;
4302 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4303 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4304 pSMB->DataCount = 0;
4305 pSMB->DataOffset = 0;
4306 pSMB->SetupCount = 1;
4307 pSMB->Reserved3 = 0;
4308 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4309 byte_count = params + 1 /* pad */ ;
4310 pSMB->TotalParameterCount = cpu_to_le16(params);
4311 pSMB->ParameterCount = pSMB->TotalParameterCount;
4312 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4313 pSMB->Reserved4 = 0;
4314 inc_rfc1001_len(pSMB, byte_count);
4315 pSMB->ByteCount = cpu_to_le16(byte_count);
4317 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4318 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4320 cFYI(1, "Send error in QPathInfo = %d", rc);
4321 } else { /* decode response */
4322 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4324 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4325 cERROR(1, "Malformed FILE_UNIX_BASIC_INFO response.\n"
4326 "Unix Extensions can be disabled on mount "
4327 "by specifying the nosfu mount option.");
4328 rc = -EIO; /* bad smb */
4330 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4331 memcpy((char *) pFindData,
4332 (char *) &pSMBr->hdr.Protocol +
4334 sizeof(FILE_UNIX_BASIC_INFO));
4337 cifs_buf_release(pSMB);
4339 goto UnixQPathInfoRetry;
4344 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4346 CIFSFindFirst(const int xid, struct cifs_tcon *tcon,
4347 const char *searchName,
4348 const struct nls_table *nls_codepage,
4350 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
4352 /* level 257 SMB_ */
4353 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4354 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
4355 T2_FFIRST_RSP_PARMS *parms;
4357 int bytes_returned = 0;
4359 __u16 params, byte_count;
4361 cFYI(1, "In FindFirst for %s", searchName);
4364 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4369 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4371 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4372 PATH_MAX, nls_codepage, remap);
4373 /* We can not add the asterik earlier in case
4374 it got remapped to 0xF03A as if it were part of the
4375 directory name instead of a wildcard */
4377 pSMB->FileName[name_len] = dirsep;
4378 pSMB->FileName[name_len+1] = 0;
4379 pSMB->FileName[name_len+2] = '*';
4380 pSMB->FileName[name_len+3] = 0;
4381 name_len += 4; /* now the trailing null */
4382 pSMB->FileName[name_len] = 0; /* null terminate just in case */
4383 pSMB->FileName[name_len+1] = 0;
4385 } else { /* BB add check for overrun of SMB buf BB */
4386 name_len = strnlen(searchName, PATH_MAX);
4387 /* BB fix here and in unicode clause above ie
4388 if (name_len > buffersize-header)
4389 free buffer exit; BB */
4390 strncpy(pSMB->FileName, searchName, name_len);
4391 pSMB->FileName[name_len] = dirsep;
4392 pSMB->FileName[name_len+1] = '*';
4393 pSMB->FileName[name_len+2] = 0;
4397 params = 12 + name_len /* includes null */ ;
4398 pSMB->TotalDataCount = 0; /* no EAs */
4399 pSMB->MaxParameterCount = cpu_to_le16(10);
4400 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4401 pSMB->MaxSetupCount = 0;
4405 pSMB->Reserved2 = 0;
4406 byte_count = params + 1 /* pad */ ;
4407 pSMB->TotalParameterCount = cpu_to_le16(params);
4408 pSMB->ParameterCount = pSMB->TotalParameterCount;
4409 pSMB->ParameterOffset = cpu_to_le16(
4410 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4412 pSMB->DataCount = 0;
4413 pSMB->DataOffset = 0;
4414 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4415 pSMB->Reserved3 = 0;
4416 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4417 pSMB->SearchAttributes =
4418 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4420 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4421 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
4422 CIFS_SEARCH_RETURN_RESUME);
4423 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4425 /* BB what should we set StorageType to? Does it matter? BB */
4426 pSMB->SearchStorageType = 0;
4427 inc_rfc1001_len(pSMB, byte_count);
4428 pSMB->ByteCount = cpu_to_le16(byte_count);
4430 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4431 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4432 cifs_stats_inc(&tcon->num_ffirst);
4434 if (rc) {/* BB add logic to retry regular search if Unix search
4435 rejected unexpectedly by server */
4436 /* BB Add code to handle unsupported level rc */
4437 cFYI(1, "Error in FindFirst = %d", rc);
4439 cifs_buf_release(pSMB);
4441 /* BB eventually could optimize out free and realloc of buf */
4444 goto findFirstRetry;
4445 } else { /* decode response */
4446 /* BB remember to free buffer if error BB */
4447 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4451 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4452 psrch_inf->unicode = true;
4454 psrch_inf->unicode = false;
4456 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4457 psrch_inf->smallBuf = 0;
4458 psrch_inf->srch_entries_start =
4459 (char *) &pSMBr->hdr.Protocol +
4460 le16_to_cpu(pSMBr->t2.DataOffset);
4461 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4462 le16_to_cpu(pSMBr->t2.ParameterOffset));
4464 if (parms->EndofSearch)
4465 psrch_inf->endOfSearch = true;
4467 psrch_inf->endOfSearch = false;
4469 psrch_inf->entries_in_buffer =
4470 le16_to_cpu(parms->SearchCount);
4471 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4472 psrch_inf->entries_in_buffer;
4473 lnoff = le16_to_cpu(parms->LastNameOffset);
4474 if (CIFSMaxBufSize < lnoff) {
4475 cERROR(1, "ignoring corrupt resume name");
4476 psrch_inf->last_entry = NULL;
4480 psrch_inf->last_entry = psrch_inf->srch_entries_start +
4483 *pnetfid = parms->SearchHandle;
4485 cifs_buf_release(pSMB);
4492 int CIFSFindNext(const int xid, struct cifs_tcon *tcon,
4493 __u16 searchHandle, struct cifs_search_info *psrch_inf)
4495 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4496 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4497 T2_FNEXT_RSP_PARMS *parms;
4498 char *response_data;
4501 unsigned int name_len;
4502 __u16 params, byte_count;
4504 cFYI(1, "In FindNext");
4506 if (psrch_inf->endOfSearch)
4509 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4514 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4516 pSMB->TotalDataCount = 0; /* no EAs */
4517 pSMB->MaxParameterCount = cpu_to_le16(8);
4518 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4519 pSMB->MaxSetupCount = 0;
4523 pSMB->Reserved2 = 0;
4524 pSMB->ParameterOffset = cpu_to_le16(
4525 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4526 pSMB->DataCount = 0;
4527 pSMB->DataOffset = 0;
4528 pSMB->SetupCount = 1;
4529 pSMB->Reserved3 = 0;
4530 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4531 pSMB->SearchHandle = searchHandle; /* always kept as le */
4533 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4534 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4535 pSMB->ResumeKey = psrch_inf->resume_key;
4537 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
4539 name_len = psrch_inf->resume_name_len;
4541 if (name_len < PATH_MAX) {
4542 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4543 byte_count += name_len;
4544 /* 14 byte parm len above enough for 2 byte null terminator */
4545 pSMB->ResumeFileName[name_len] = 0;
4546 pSMB->ResumeFileName[name_len+1] = 0;
4549 goto FNext2_err_exit;
4551 byte_count = params + 1 /* pad */ ;
4552 pSMB->TotalParameterCount = cpu_to_le16(params);
4553 pSMB->ParameterCount = pSMB->TotalParameterCount;
4554 inc_rfc1001_len(pSMB, byte_count);
4555 pSMB->ByteCount = cpu_to_le16(byte_count);
4557 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4558 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4559 cifs_stats_inc(&tcon->num_fnext);
4562 psrch_inf->endOfSearch = true;
4563 cifs_buf_release(pSMB);
4564 rc = 0; /* search probably was closed at end of search*/
4566 cFYI(1, "FindNext returned = %d", rc);
4567 } else { /* decode response */
4568 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4573 /* BB fixme add lock for file (srch_info) struct here */
4574 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4575 psrch_inf->unicode = true;
4577 psrch_inf->unicode = false;
4578 response_data = (char *) &pSMBr->hdr.Protocol +
4579 le16_to_cpu(pSMBr->t2.ParameterOffset);
4580 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4581 response_data = (char *)&pSMBr->hdr.Protocol +
4582 le16_to_cpu(pSMBr->t2.DataOffset);
4583 if (psrch_inf->smallBuf)
4584 cifs_small_buf_release(
4585 psrch_inf->ntwrk_buf_start);
4587 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4588 psrch_inf->srch_entries_start = response_data;
4589 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4590 psrch_inf->smallBuf = 0;
4591 if (parms->EndofSearch)
4592 psrch_inf->endOfSearch = true;
4594 psrch_inf->endOfSearch = false;
4595 psrch_inf->entries_in_buffer =
4596 le16_to_cpu(parms->SearchCount);
4597 psrch_inf->index_of_last_entry +=
4598 psrch_inf->entries_in_buffer;
4599 lnoff = le16_to_cpu(parms->LastNameOffset);
4600 if (CIFSMaxBufSize < lnoff) {
4601 cERROR(1, "ignoring corrupt resume name");
4602 psrch_inf->last_entry = NULL;
4605 psrch_inf->last_entry =
4606 psrch_inf->srch_entries_start + lnoff;
4608 /* cFYI(1, "fnxt2 entries in buf %d index_of_last %d",
4609 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4611 /* BB fixme add unlock here */
4616 /* BB On error, should we leave previous search buf (and count and
4617 last entry fields) intact or free the previous one? */
4619 /* Note: On -EAGAIN error only caller can retry on handle based calls
4620 since file handle passed in no longer valid */
4623 cifs_buf_release(pSMB);
4628 CIFSFindClose(const int xid, struct cifs_tcon *tcon,
4629 const __u16 searchHandle)
4632 FINDCLOSE_REQ *pSMB = NULL;
4634 cFYI(1, "In CIFSSMBFindClose");
4635 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4637 /* no sense returning error if session restarted
4638 as file handle has been closed */
4644 pSMB->FileID = searchHandle;
4645 pSMB->ByteCount = 0;
4646 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4648 cERROR(1, "Send error in FindClose = %d", rc);
4650 cifs_stats_inc(&tcon->num_fclose);
4652 /* Since session is dead, search handle closed on server already */
4660 CIFSGetSrvInodeNumber(const int xid, struct cifs_tcon *tcon,
4661 const unsigned char *searchName,
4662 __u64 *inode_number,
4663 const struct nls_table *nls_codepage, int remap)
4666 TRANSACTION2_QPI_REQ *pSMB = NULL;
4667 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4668 int name_len, bytes_returned;
4669 __u16 params, byte_count;
4671 cFYI(1, "In GetSrvInodeNum for %s", searchName);
4675 GetInodeNumberRetry:
4676 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4681 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4683 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4684 searchName, PATH_MAX, nls_codepage,
4686 name_len++; /* trailing null */
4688 } else { /* BB improve the check for buffer overruns BB */
4689 name_len = strnlen(searchName, PATH_MAX);
4690 name_len++; /* trailing null */
4691 strncpy(pSMB->FileName, searchName, name_len);
4694 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4695 pSMB->TotalDataCount = 0;
4696 pSMB->MaxParameterCount = cpu_to_le16(2);
4697 /* BB find exact max data count below from sess structure BB */
4698 pSMB->MaxDataCount = cpu_to_le16(4000);
4699 pSMB->MaxSetupCount = 0;
4703 pSMB->Reserved2 = 0;
4704 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4705 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4706 pSMB->DataCount = 0;
4707 pSMB->DataOffset = 0;
4708 pSMB->SetupCount = 1;
4709 pSMB->Reserved3 = 0;
4710 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4711 byte_count = params + 1 /* pad */ ;
4712 pSMB->TotalParameterCount = cpu_to_le16(params);
4713 pSMB->ParameterCount = pSMB->TotalParameterCount;
4714 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4715 pSMB->Reserved4 = 0;
4716 inc_rfc1001_len(pSMB, byte_count);
4717 pSMB->ByteCount = cpu_to_le16(byte_count);
4719 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4720 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4722 cFYI(1, "error %d in QueryInternalInfo", rc);
4724 /* decode response */
4725 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4726 /* BB also check enough total bytes returned */
4727 if (rc || get_bcc(&pSMBr->hdr) < 2)
4728 /* If rc should we check for EOPNOSUPP and
4729 disable the srvino flag? or in caller? */
4730 rc = -EIO; /* bad smb */
4732 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4733 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4734 struct file_internal_info *pfinfo;
4735 /* BB Do we need a cast or hash here ? */
4737 cFYI(1, "Illegal size ret in QryIntrnlInf");
4739 goto GetInodeNumOut;
4741 pfinfo = (struct file_internal_info *)
4742 (data_offset + (char *) &pSMBr->hdr.Protocol);
4743 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4747 cifs_buf_release(pSMB);
4749 goto GetInodeNumberRetry;
4753 /* parses DFS refferal V3 structure
4754 * caller is responsible for freeing target_nodes
4757 * on failure - errno
4760 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
4761 unsigned int *num_of_nodes,
4762 struct dfs_info3_param **target_nodes,
4763 const struct nls_table *nls_codepage, int remap,
4764 const char *searchName)
4769 struct dfs_referral_level_3 *ref;
4771 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4775 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4777 if (*num_of_nodes < 1) {
4778 cERROR(1, "num_referrals: must be at least > 0,"
4779 "but we get num_referrals = %d\n", *num_of_nodes);
4781 goto parse_DFS_referrals_exit;
4784 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
4785 if (ref->VersionNumber != cpu_to_le16(3)) {
4786 cERROR(1, "Referrals of V%d version are not supported,"
4787 "should be V3", le16_to_cpu(ref->VersionNumber));
4789 goto parse_DFS_referrals_exit;
4792 /* get the upper boundary of the resp buffer */
4793 data_end = (char *)(&(pSMBr->PathConsumed)) +
4794 le16_to_cpu(pSMBr->t2.DataCount);
4796 cFYI(1, "num_referrals: %d dfs flags: 0x%x ...\n",
4798 le32_to_cpu(pSMBr->DFSFlags));
4800 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
4801 *num_of_nodes, GFP_KERNEL);
4802 if (*target_nodes == NULL) {
4803 cERROR(1, "Failed to allocate buffer for target_nodes\n");
4805 goto parse_DFS_referrals_exit;
4808 /* collect necessary data from referrals */
4809 for (i = 0; i < *num_of_nodes; i++) {
4812 struct dfs_info3_param *node = (*target_nodes)+i;
4814 node->flags = le32_to_cpu(pSMBr->DFSFlags);
4816 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4820 goto parse_DFS_referrals_exit;
4822 cifsConvertToUTF16((__le16 *) tmp, searchName,
4823 PATH_MAX, nls_codepage, remap);
4824 node->path_consumed = cifs_utf16_bytes(tmp,
4825 le16_to_cpu(pSMBr->PathConsumed),
4829 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4831 node->server_type = le16_to_cpu(ref->ServerType);
4832 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4835 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4836 max_len = data_end - temp;
4837 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4838 is_unicode, nls_codepage);
4839 if (!node->path_name) {
4841 goto parse_DFS_referrals_exit;
4844 /* copy link target UNC */
4845 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4846 max_len = data_end - temp;
4847 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4848 is_unicode, nls_codepage);
4849 if (!node->node_name)
4853 parse_DFS_referrals_exit:
4855 free_dfs_info_array(*target_nodes, *num_of_nodes);
4856 *target_nodes = NULL;
4863 CIFSGetDFSRefer(const int xid, struct cifs_ses *ses,
4864 const unsigned char *searchName,
4865 struct dfs_info3_param **target_nodes,
4866 unsigned int *num_of_nodes,
4867 const struct nls_table *nls_codepage, int remap)
4869 /* TRANS2_GET_DFS_REFERRAL */
4870 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4871 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4875 __u16 params, byte_count;
4877 *target_nodes = NULL;
4879 cFYI(1, "In GetDFSRefer the path %s", searchName);
4883 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4888 /* server pointer checked in called function,
4889 but should never be null here anyway */
4890 pSMB->hdr.Mid = GetNextMid(ses->server);
4891 pSMB->hdr.Tid = ses->ipc_tid;
4892 pSMB->hdr.Uid = ses->Suid;
4893 if (ses->capabilities & CAP_STATUS32)
4894 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4895 if (ses->capabilities & CAP_DFS)
4896 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4898 if (ses->capabilities & CAP_UNICODE) {
4899 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4901 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4902 searchName, PATH_MAX, nls_codepage,
4904 name_len++; /* trailing null */
4906 } else { /* BB improve the check for buffer overruns BB */
4907 name_len = strnlen(searchName, PATH_MAX);
4908 name_len++; /* trailing null */
4909 strncpy(pSMB->RequestFileName, searchName, name_len);
4913 if (ses->server->sec_mode &
4914 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4915 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4918 pSMB->hdr.Uid = ses->Suid;
4920 params = 2 /* level */ + name_len /*includes null */ ;
4921 pSMB->TotalDataCount = 0;
4922 pSMB->DataCount = 0;
4923 pSMB->DataOffset = 0;
4924 pSMB->MaxParameterCount = 0;
4925 /* BB find exact max SMB PDU from sess structure BB */
4926 pSMB->MaxDataCount = cpu_to_le16(4000);
4927 pSMB->MaxSetupCount = 0;
4931 pSMB->Reserved2 = 0;
4932 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4933 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4934 pSMB->SetupCount = 1;
4935 pSMB->Reserved3 = 0;
4936 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4937 byte_count = params + 3 /* pad */ ;
4938 pSMB->ParameterCount = cpu_to_le16(params);
4939 pSMB->TotalParameterCount = pSMB->ParameterCount;
4940 pSMB->MaxReferralLevel = cpu_to_le16(3);
4941 inc_rfc1001_len(pSMB, byte_count);
4942 pSMB->ByteCount = cpu_to_le16(byte_count);
4944 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4945 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4947 cFYI(1, "Send error in GetDFSRefer = %d", rc);
4950 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4952 /* BB Also check if enough total bytes returned? */
4953 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4954 rc = -EIO; /* bad smb */
4958 cFYI(1, "Decoding GetDFSRefer response BCC: %d Offset %d",
4959 get_bcc(&pSMBr->hdr),
4960 le16_to_cpu(pSMBr->t2.DataOffset));
4962 /* parse returned result into more usable form */
4963 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
4964 target_nodes, nls_codepage, remap,
4968 cifs_buf_release(pSMB);
4976 /* Query File System Info such as free space to old servers such as Win 9x */
4978 SMBOldQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
4980 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4981 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4982 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4983 FILE_SYSTEM_ALLOC_INFO *response_data;
4985 int bytes_returned = 0;
4986 __u16 params, byte_count;
4988 cFYI(1, "OldQFSInfo");
4990 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4995 params = 2; /* level */
4996 pSMB->TotalDataCount = 0;
4997 pSMB->MaxParameterCount = cpu_to_le16(2);
4998 pSMB->MaxDataCount = cpu_to_le16(1000);
4999 pSMB->MaxSetupCount = 0;
5003 pSMB->Reserved2 = 0;
5004 byte_count = params + 1 /* pad */ ;
5005 pSMB->TotalParameterCount = cpu_to_le16(params);
5006 pSMB->ParameterCount = pSMB->TotalParameterCount;
5007 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5008 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5009 pSMB->DataCount = 0;
5010 pSMB->DataOffset = 0;
5011 pSMB->SetupCount = 1;
5012 pSMB->Reserved3 = 0;
5013 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5014 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
5015 inc_rfc1001_len(pSMB, byte_count);
5016 pSMB->ByteCount = cpu_to_le16(byte_count);
5018 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5019 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5021 cFYI(1, "Send error in QFSInfo = %d", rc);
5022 } else { /* decode response */
5023 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5025 if (rc || get_bcc(&pSMBr->hdr) < 18)
5026 rc = -EIO; /* bad smb */
5028 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5029 cFYI(1, "qfsinf resp BCC: %d Offset %d",
5030 get_bcc(&pSMBr->hdr), data_offset);
5032 response_data = (FILE_SYSTEM_ALLOC_INFO *)
5033 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5035 le16_to_cpu(response_data->BytesPerSector) *
5036 le32_to_cpu(response_data->
5037 SectorsPerAllocationUnit);
5039 le32_to_cpu(response_data->TotalAllocationUnits);
5040 FSData->f_bfree = FSData->f_bavail =
5041 le32_to_cpu(response_data->FreeAllocationUnits);
5042 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5043 (unsigned long long)FSData->f_blocks,
5044 (unsigned long long)FSData->f_bfree,
5048 cifs_buf_release(pSMB);
5051 goto oldQFSInfoRetry;
5057 CIFSSMBQFSInfo(const int xid, struct cifs_tcon *tcon, struct kstatfs *FSData)
5059 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5060 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5061 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5062 FILE_SYSTEM_INFO *response_data;
5064 int bytes_returned = 0;
5065 __u16 params, byte_count;
5067 cFYI(1, "In QFSInfo");
5069 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5074 params = 2; /* level */
5075 pSMB->TotalDataCount = 0;
5076 pSMB->MaxParameterCount = cpu_to_le16(2);
5077 pSMB->MaxDataCount = cpu_to_le16(1000);
5078 pSMB->MaxSetupCount = 0;
5082 pSMB->Reserved2 = 0;
5083 byte_count = params + 1 /* pad */ ;
5084 pSMB->TotalParameterCount = cpu_to_le16(params);
5085 pSMB->ParameterCount = pSMB->TotalParameterCount;
5086 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5087 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5088 pSMB->DataCount = 0;
5089 pSMB->DataOffset = 0;
5090 pSMB->SetupCount = 1;
5091 pSMB->Reserved3 = 0;
5092 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5093 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
5094 inc_rfc1001_len(pSMB, byte_count);
5095 pSMB->ByteCount = cpu_to_le16(byte_count);
5097 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5098 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5100 cFYI(1, "Send error in QFSInfo = %d", rc);
5101 } else { /* decode response */
5102 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5104 if (rc || get_bcc(&pSMBr->hdr) < 24)
5105 rc = -EIO; /* bad smb */
5107 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5111 *) (((char *) &pSMBr->hdr.Protocol) +
5114 le32_to_cpu(response_data->BytesPerSector) *
5115 le32_to_cpu(response_data->
5116 SectorsPerAllocationUnit);
5118 le64_to_cpu(response_data->TotalAllocationUnits);
5119 FSData->f_bfree = FSData->f_bavail =
5120 le64_to_cpu(response_data->FreeAllocationUnits);
5121 cFYI(1, "Blocks: %lld Free: %lld Block size %ld",
5122 (unsigned long long)FSData->f_blocks,
5123 (unsigned long long)FSData->f_bfree,
5127 cifs_buf_release(pSMB);
5136 CIFSSMBQFSAttributeInfo(const int xid, struct cifs_tcon *tcon)
5138 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5139 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5140 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5141 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5143 int bytes_returned = 0;
5144 __u16 params, byte_count;
5146 cFYI(1, "In QFSAttributeInfo");
5148 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5153 params = 2; /* level */
5154 pSMB->TotalDataCount = 0;
5155 pSMB->MaxParameterCount = cpu_to_le16(2);
5156 /* BB find exact max SMB PDU from sess structure BB */
5157 pSMB->MaxDataCount = cpu_to_le16(1000);
5158 pSMB->MaxSetupCount = 0;
5162 pSMB->Reserved2 = 0;
5163 byte_count = params + 1 /* pad */ ;
5164 pSMB->TotalParameterCount = cpu_to_le16(params);
5165 pSMB->ParameterCount = pSMB->TotalParameterCount;
5166 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5167 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5168 pSMB->DataCount = 0;
5169 pSMB->DataOffset = 0;
5170 pSMB->SetupCount = 1;
5171 pSMB->Reserved3 = 0;
5172 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5173 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
5174 inc_rfc1001_len(pSMB, byte_count);
5175 pSMB->ByteCount = cpu_to_le16(byte_count);
5177 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5178 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5180 cERROR(1, "Send error in QFSAttributeInfo = %d", rc);
5181 } else { /* decode response */
5182 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5184 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5185 /* BB also check if enough bytes returned */
5186 rc = -EIO; /* bad smb */
5188 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5190 (FILE_SYSTEM_ATTRIBUTE_INFO
5191 *) (((char *) &pSMBr->hdr.Protocol) +
5193 memcpy(&tcon->fsAttrInfo, response_data,
5194 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
5197 cifs_buf_release(pSMB);
5200 goto QFSAttributeRetry;
5206 CIFSSMBQFSDeviceInfo(const int xid, struct cifs_tcon *tcon)
5208 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5209 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5210 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5211 FILE_SYSTEM_DEVICE_INFO *response_data;
5213 int bytes_returned = 0;
5214 __u16 params, byte_count;
5216 cFYI(1, "In QFSDeviceInfo");
5218 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5223 params = 2; /* level */
5224 pSMB->TotalDataCount = 0;
5225 pSMB->MaxParameterCount = cpu_to_le16(2);
5226 /* BB find exact max SMB PDU from sess structure BB */
5227 pSMB->MaxDataCount = cpu_to_le16(1000);
5228 pSMB->MaxSetupCount = 0;
5232 pSMB->Reserved2 = 0;
5233 byte_count = params + 1 /* pad */ ;
5234 pSMB->TotalParameterCount = cpu_to_le16(params);
5235 pSMB->ParameterCount = pSMB->TotalParameterCount;
5236 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5237 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5239 pSMB->DataCount = 0;
5240 pSMB->DataOffset = 0;
5241 pSMB->SetupCount = 1;
5242 pSMB->Reserved3 = 0;
5243 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5244 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
5245 inc_rfc1001_len(pSMB, byte_count);
5246 pSMB->ByteCount = cpu_to_le16(byte_count);
5248 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5249 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5251 cFYI(1, "Send error in QFSDeviceInfo = %d", rc);
5252 } else { /* decode response */
5253 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5255 if (rc || get_bcc(&pSMBr->hdr) <
5256 sizeof(FILE_SYSTEM_DEVICE_INFO))
5257 rc = -EIO; /* bad smb */
5259 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5261 (FILE_SYSTEM_DEVICE_INFO *)
5262 (((char *) &pSMBr->hdr.Protocol) +
5264 memcpy(&tcon->fsDevInfo, response_data,
5265 sizeof(FILE_SYSTEM_DEVICE_INFO));
5268 cifs_buf_release(pSMB);
5271 goto QFSDeviceRetry;
5277 CIFSSMBQFSUnixInfo(const int xid, struct cifs_tcon *tcon)
5279 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5280 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5281 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5282 FILE_SYSTEM_UNIX_INFO *response_data;
5284 int bytes_returned = 0;
5285 __u16 params, byte_count;
5287 cFYI(1, "In QFSUnixInfo");
5289 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5290 (void **) &pSMB, (void **) &pSMBr);
5294 params = 2; /* level */
5295 pSMB->TotalDataCount = 0;
5296 pSMB->DataCount = 0;
5297 pSMB->DataOffset = 0;
5298 pSMB->MaxParameterCount = cpu_to_le16(2);
5299 /* BB find exact max SMB PDU from sess structure BB */
5300 pSMB->MaxDataCount = cpu_to_le16(100);
5301 pSMB->MaxSetupCount = 0;
5305 pSMB->Reserved2 = 0;
5306 byte_count = params + 1 /* pad */ ;
5307 pSMB->ParameterCount = cpu_to_le16(params);
5308 pSMB->TotalParameterCount = pSMB->ParameterCount;
5309 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5310 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5311 pSMB->SetupCount = 1;
5312 pSMB->Reserved3 = 0;
5313 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5314 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
5315 inc_rfc1001_len(pSMB, byte_count);
5316 pSMB->ByteCount = cpu_to_le16(byte_count);
5318 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5319 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5321 cERROR(1, "Send error in QFSUnixInfo = %d", rc);
5322 } else { /* decode response */
5323 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5325 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5326 rc = -EIO; /* bad smb */
5328 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5330 (FILE_SYSTEM_UNIX_INFO
5331 *) (((char *) &pSMBr->hdr.Protocol) +
5333 memcpy(&tcon->fsUnixInfo, response_data,
5334 sizeof(FILE_SYSTEM_UNIX_INFO));
5337 cifs_buf_release(pSMB);
5347 CIFSSMBSetFSUnixInfo(const int xid, struct cifs_tcon *tcon, __u64 cap)
5349 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5350 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5351 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5353 int bytes_returned = 0;
5354 __u16 params, param_offset, offset, byte_count;
5356 cFYI(1, "In SETFSUnixInfo");
5358 /* BB switch to small buf init to save memory */
5359 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5360 (void **) &pSMB, (void **) &pSMBr);
5364 params = 4; /* 2 bytes zero followed by info level. */
5365 pSMB->MaxSetupCount = 0;
5369 pSMB->Reserved2 = 0;
5370 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5372 offset = param_offset + params;
5374 pSMB->MaxParameterCount = cpu_to_le16(4);
5375 /* BB find exact max SMB PDU from sess structure BB */
5376 pSMB->MaxDataCount = cpu_to_le16(100);
5377 pSMB->SetupCount = 1;
5378 pSMB->Reserved3 = 0;
5379 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5380 byte_count = 1 /* pad */ + params + 12;
5382 pSMB->DataCount = cpu_to_le16(12);
5383 pSMB->ParameterCount = cpu_to_le16(params);
5384 pSMB->TotalDataCount = pSMB->DataCount;
5385 pSMB->TotalParameterCount = pSMB->ParameterCount;
5386 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5387 pSMB->DataOffset = cpu_to_le16(offset);
5391 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5394 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5395 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5396 pSMB->ClientUnixCap = cpu_to_le64(cap);
5398 inc_rfc1001_len(pSMB, byte_count);
5399 pSMB->ByteCount = cpu_to_le16(byte_count);
5401 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5402 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5404 cERROR(1, "Send error in SETFSUnixInfo = %d", rc);
5405 } else { /* decode response */
5406 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5408 rc = -EIO; /* bad smb */
5410 cifs_buf_release(pSMB);
5413 goto SETFSUnixRetry;
5421 CIFSSMBQFSPosixInfo(const int xid, struct cifs_tcon *tcon,
5422 struct kstatfs *FSData)
5424 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5425 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5426 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5427 FILE_SYSTEM_POSIX_INFO *response_data;
5429 int bytes_returned = 0;
5430 __u16 params, byte_count;
5432 cFYI(1, "In QFSPosixInfo");
5434 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5439 params = 2; /* level */
5440 pSMB->TotalDataCount = 0;
5441 pSMB->DataCount = 0;
5442 pSMB->DataOffset = 0;
5443 pSMB->MaxParameterCount = cpu_to_le16(2);
5444 /* BB find exact max SMB PDU from sess structure BB */
5445 pSMB->MaxDataCount = cpu_to_le16(100);
5446 pSMB->MaxSetupCount = 0;
5450 pSMB->Reserved2 = 0;
5451 byte_count = params + 1 /* pad */ ;
5452 pSMB->ParameterCount = cpu_to_le16(params);
5453 pSMB->TotalParameterCount = pSMB->ParameterCount;
5454 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5455 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5456 pSMB->SetupCount = 1;
5457 pSMB->Reserved3 = 0;
5458 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5459 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
5460 inc_rfc1001_len(pSMB, byte_count);
5461 pSMB->ByteCount = cpu_to_le16(byte_count);
5463 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5464 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5466 cFYI(1, "Send error in QFSUnixInfo = %d", rc);
5467 } else { /* decode response */
5468 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5470 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5471 rc = -EIO; /* bad smb */
5473 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5475 (FILE_SYSTEM_POSIX_INFO
5476 *) (((char *) &pSMBr->hdr.Protocol) +
5479 le32_to_cpu(response_data->BlockSize);
5481 le64_to_cpu(response_data->TotalBlocks);
5483 le64_to_cpu(response_data->BlocksAvail);
5484 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
5485 FSData->f_bavail = FSData->f_bfree;
5488 le64_to_cpu(response_data->UserBlocksAvail);
5490 if (response_data->TotalFileNodes != cpu_to_le64(-1))
5492 le64_to_cpu(response_data->TotalFileNodes);
5493 if (response_data->FreeFileNodes != cpu_to_le64(-1))
5495 le64_to_cpu(response_data->FreeFileNodes);
5498 cifs_buf_release(pSMB);
5507 /* We can not use write of zero bytes trick to
5508 set file size due to need for large file support. Also note that
5509 this SetPathInfo is preferred to SetFileInfo based method in next
5510 routine which is only needed to work around a sharing violation bug
5511 in Samba which this routine can run into */
5514 CIFSSMBSetEOF(const int xid, struct cifs_tcon *tcon, const char *fileName,
5515 __u64 size, bool SetAllocation,
5516 const struct nls_table *nls_codepage, int remap)
5518 struct smb_com_transaction2_spi_req *pSMB = NULL;
5519 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5520 struct file_end_of_file_info *parm_data;
5523 int bytes_returned = 0;
5524 __u16 params, byte_count, data_count, param_offset, offset;
5526 cFYI(1, "In SetEOF");
5528 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5533 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5535 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5536 PATH_MAX, nls_codepage, remap);
5537 name_len++; /* trailing null */
5539 } else { /* BB improve the check for buffer overruns BB */
5540 name_len = strnlen(fileName, PATH_MAX);
5541 name_len++; /* trailing null */
5542 strncpy(pSMB->FileName, fileName, name_len);
5544 params = 6 + name_len;
5545 data_count = sizeof(struct file_end_of_file_info);
5546 pSMB->MaxParameterCount = cpu_to_le16(2);
5547 pSMB->MaxDataCount = cpu_to_le16(4100);
5548 pSMB->MaxSetupCount = 0;
5552 pSMB->Reserved2 = 0;
5553 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5554 InformationLevel) - 4;
5555 offset = param_offset + params;
5556 if (SetAllocation) {
5557 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5558 pSMB->InformationLevel =
5559 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5561 pSMB->InformationLevel =
5562 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5563 } else /* Set File Size */ {
5564 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5565 pSMB->InformationLevel =
5566 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5568 pSMB->InformationLevel =
5569 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5573 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5575 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5576 pSMB->DataOffset = cpu_to_le16(offset);
5577 pSMB->SetupCount = 1;
5578 pSMB->Reserved3 = 0;
5579 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5580 byte_count = 3 /* pad */ + params + data_count;
5581 pSMB->DataCount = cpu_to_le16(data_count);
5582 pSMB->TotalDataCount = pSMB->DataCount;
5583 pSMB->ParameterCount = cpu_to_le16(params);
5584 pSMB->TotalParameterCount = pSMB->ParameterCount;
5585 pSMB->Reserved4 = 0;
5586 inc_rfc1001_len(pSMB, byte_count);
5587 parm_data->FileSize = cpu_to_le64(size);
5588 pSMB->ByteCount = cpu_to_le16(byte_count);
5589 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5590 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5592 cFYI(1, "SetPathInfo (file size) returned %d", rc);
5594 cifs_buf_release(pSMB);
5603 CIFSSMBSetFileSize(const int xid, struct cifs_tcon *tcon, __u64 size,
5604 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
5606 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5607 struct file_end_of_file_info *parm_data;
5609 __u16 params, param_offset, offset, byte_count, count;
5611 cFYI(1, "SetFileSize (via SetFileInfo) %lld",
5613 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5618 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5619 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5622 pSMB->MaxSetupCount = 0;
5626 pSMB->Reserved2 = 0;
5627 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5628 offset = param_offset + params;
5630 count = sizeof(struct file_end_of_file_info);
5631 pSMB->MaxParameterCount = cpu_to_le16(2);
5632 /* BB find exact max SMB PDU from sess structure BB */
5633 pSMB->MaxDataCount = cpu_to_le16(1000);
5634 pSMB->SetupCount = 1;
5635 pSMB->Reserved3 = 0;
5636 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5637 byte_count = 3 /* pad */ + params + count;
5638 pSMB->DataCount = cpu_to_le16(count);
5639 pSMB->ParameterCount = cpu_to_le16(params);
5640 pSMB->TotalDataCount = pSMB->DataCount;
5641 pSMB->TotalParameterCount = pSMB->ParameterCount;
5642 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5644 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5646 pSMB->DataOffset = cpu_to_le16(offset);
5647 parm_data->FileSize = cpu_to_le64(size);
5649 if (SetAllocation) {
5650 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5651 pSMB->InformationLevel =
5652 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5654 pSMB->InformationLevel =
5655 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5656 } else /* Set File Size */ {
5657 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5658 pSMB->InformationLevel =
5659 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5661 pSMB->InformationLevel =
5662 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5664 pSMB->Reserved4 = 0;
5665 inc_rfc1001_len(pSMB, byte_count);
5666 pSMB->ByteCount = cpu_to_le16(byte_count);
5667 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5669 cFYI(1, "Send error in SetFileInfo (SetFileSize) = %d", rc);
5672 /* Note: On -EAGAIN error only caller can retry on handle based calls
5673 since file handle passed in no longer valid */
5678 /* Some legacy servers such as NT4 require that the file times be set on
5679 an open handle, rather than by pathname - this is awkward due to
5680 potential access conflicts on the open, but it is unavoidable for these
5681 old servers since the only other choice is to go from 100 nanosecond DCE
5682 time and resort to the original setpathinfo level which takes the ancient
5683 DOS time format with 2 second granularity */
5685 CIFSSMBSetFileInfo(const int xid, struct cifs_tcon *tcon,
5686 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5688 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5691 __u16 params, param_offset, offset, byte_count, count;
5693 cFYI(1, "Set Times (via SetFileInfo)");
5694 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5699 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5700 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5703 pSMB->MaxSetupCount = 0;
5707 pSMB->Reserved2 = 0;
5708 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5709 offset = param_offset + params;
5711 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5713 count = sizeof(FILE_BASIC_INFO);
5714 pSMB->MaxParameterCount = cpu_to_le16(2);
5715 /* BB find max SMB PDU from sess */
5716 pSMB->MaxDataCount = cpu_to_le16(1000);
5717 pSMB->SetupCount = 1;
5718 pSMB->Reserved3 = 0;
5719 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5720 byte_count = 3 /* pad */ + params + count;
5721 pSMB->DataCount = cpu_to_le16(count);
5722 pSMB->ParameterCount = cpu_to_le16(params);
5723 pSMB->TotalDataCount = pSMB->DataCount;
5724 pSMB->TotalParameterCount = pSMB->ParameterCount;
5725 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5726 pSMB->DataOffset = cpu_to_le16(offset);
5728 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5729 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5731 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5732 pSMB->Reserved4 = 0;
5733 inc_rfc1001_len(pSMB, byte_count);
5734 pSMB->ByteCount = cpu_to_le16(byte_count);
5735 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5736 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5738 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
5740 /* Note: On -EAGAIN error only caller can retry on handle based calls
5741 since file handle passed in no longer valid */
5747 CIFSSMBSetFileDisposition(const int xid, struct cifs_tcon *tcon,
5748 bool delete_file, __u16 fid, __u32 pid_of_opener)
5750 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5753 __u16 params, param_offset, offset, byte_count, count;
5755 cFYI(1, "Set File Disposition (via SetFileInfo)");
5756 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5761 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5762 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5765 pSMB->MaxSetupCount = 0;
5769 pSMB->Reserved2 = 0;
5770 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5771 offset = param_offset + params;
5773 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5776 pSMB->MaxParameterCount = cpu_to_le16(2);
5777 /* BB find max SMB PDU from sess */
5778 pSMB->MaxDataCount = cpu_to_le16(1000);
5779 pSMB->SetupCount = 1;
5780 pSMB->Reserved3 = 0;
5781 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5782 byte_count = 3 /* pad */ + params + count;
5783 pSMB->DataCount = cpu_to_le16(count);
5784 pSMB->ParameterCount = cpu_to_le16(params);
5785 pSMB->TotalDataCount = pSMB->DataCount;
5786 pSMB->TotalParameterCount = pSMB->ParameterCount;
5787 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5788 pSMB->DataOffset = cpu_to_le16(offset);
5790 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5791 pSMB->Reserved4 = 0;
5792 inc_rfc1001_len(pSMB, byte_count);
5793 pSMB->ByteCount = cpu_to_le16(byte_count);
5794 *data_offset = delete_file ? 1 : 0;
5795 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5797 cFYI(1, "Send error in SetFileDisposition = %d", rc);
5803 CIFSSMBSetPathInfo(const int xid, struct cifs_tcon *tcon,
5804 const char *fileName, const FILE_BASIC_INFO *data,
5805 const struct nls_table *nls_codepage, int remap)
5807 TRANSACTION2_SPI_REQ *pSMB = NULL;
5808 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5811 int bytes_returned = 0;
5813 __u16 params, param_offset, offset, byte_count, count;
5815 cFYI(1, "In SetTimes");
5818 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5823 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5825 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5826 PATH_MAX, nls_codepage, remap);
5827 name_len++; /* trailing null */
5829 } else { /* BB improve the check for buffer overruns BB */
5830 name_len = strnlen(fileName, PATH_MAX);
5831 name_len++; /* trailing null */
5832 strncpy(pSMB->FileName, fileName, name_len);
5835 params = 6 + name_len;
5836 count = sizeof(FILE_BASIC_INFO);
5837 pSMB->MaxParameterCount = cpu_to_le16(2);
5838 /* BB find max SMB PDU from sess structure BB */
5839 pSMB->MaxDataCount = cpu_to_le16(1000);
5840 pSMB->MaxSetupCount = 0;
5844 pSMB->Reserved2 = 0;
5845 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5846 InformationLevel) - 4;
5847 offset = param_offset + params;
5848 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5849 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5850 pSMB->DataOffset = cpu_to_le16(offset);
5851 pSMB->SetupCount = 1;
5852 pSMB->Reserved3 = 0;
5853 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5854 byte_count = 3 /* pad */ + params + count;
5856 pSMB->DataCount = cpu_to_le16(count);
5857 pSMB->ParameterCount = cpu_to_le16(params);
5858 pSMB->TotalDataCount = pSMB->DataCount;
5859 pSMB->TotalParameterCount = pSMB->ParameterCount;
5860 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5861 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5863 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5864 pSMB->Reserved4 = 0;
5865 inc_rfc1001_len(pSMB, byte_count);
5866 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5867 pSMB->ByteCount = cpu_to_le16(byte_count);
5868 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5869 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5871 cFYI(1, "SetPathInfo (times) returned %d", rc);
5873 cifs_buf_release(pSMB);
5881 /* Can not be used to set time stamps yet (due to old DOS time format) */
5882 /* Can be used to set attributes */
5883 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5884 handling it anyway and NT4 was what we thought it would be needed for
5885 Do not delete it until we prove whether needed for Win9x though */
5887 CIFSSMBSetAttrLegacy(int xid, struct cifs_tcon *tcon, char *fileName,
5888 __u16 dos_attrs, const struct nls_table *nls_codepage)
5890 SETATTR_REQ *pSMB = NULL;
5891 SETATTR_RSP *pSMBr = NULL;
5896 cFYI(1, "In SetAttrLegacy");
5899 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5904 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5906 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5907 PATH_MAX, nls_codepage);
5908 name_len++; /* trailing null */
5910 } else { /* BB improve the check for buffer overruns BB */
5911 name_len = strnlen(fileName, PATH_MAX);
5912 name_len++; /* trailing null */
5913 strncpy(pSMB->fileName, fileName, name_len);
5915 pSMB->attr = cpu_to_le16(dos_attrs);
5916 pSMB->BufferFormat = 0x04;
5917 inc_rfc1001_len(pSMB, name_len + 1);
5918 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5919 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5920 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5922 cFYI(1, "Error in LegacySetAttr = %d", rc);
5924 cifs_buf_release(pSMB);
5927 goto SetAttrLgcyRetry;
5931 #endif /* temporarily unneeded SetAttr legacy function */
5934 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5935 const struct cifs_unix_set_info_args *args)
5937 u64 mode = args->mode;
5940 * Samba server ignores set of file size to zero due to bugs in some
5941 * older clients, but we should be precise - we use SetFileSize to
5942 * set file size and do not want to truncate file size to zero
5943 * accidentally as happened on one Samba server beta by putting
5944 * zero instead of -1 here
5946 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5947 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5948 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5949 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5950 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5951 data_offset->Uid = cpu_to_le64(args->uid);
5952 data_offset->Gid = cpu_to_le64(args->gid);
5953 /* better to leave device as zero when it is */
5954 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5955 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5956 data_offset->Permissions = cpu_to_le64(mode);
5959 data_offset->Type = cpu_to_le32(UNIX_FILE);
5960 else if (S_ISDIR(mode))
5961 data_offset->Type = cpu_to_le32(UNIX_DIR);
5962 else if (S_ISLNK(mode))
5963 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5964 else if (S_ISCHR(mode))
5965 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5966 else if (S_ISBLK(mode))
5967 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5968 else if (S_ISFIFO(mode))
5969 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5970 else if (S_ISSOCK(mode))
5971 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5975 CIFSSMBUnixSetFileInfo(const int xid, struct cifs_tcon *tcon,
5976 const struct cifs_unix_set_info_args *args,
5977 u16 fid, u32 pid_of_opener)
5979 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5980 FILE_UNIX_BASIC_INFO *data_offset;
5982 u16 params, param_offset, offset, byte_count, count;
5984 cFYI(1, "Set Unix Info (via SetFileInfo)");
5985 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5990 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5991 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5994 pSMB->MaxSetupCount = 0;
5998 pSMB->Reserved2 = 0;
5999 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
6000 offset = param_offset + params;
6002 data_offset = (FILE_UNIX_BASIC_INFO *)
6003 ((char *)(&pSMB->hdr.Protocol) + offset);
6004 count = sizeof(FILE_UNIX_BASIC_INFO);
6006 pSMB->MaxParameterCount = cpu_to_le16(2);
6007 /* BB find max SMB PDU from sess */
6008 pSMB->MaxDataCount = cpu_to_le16(1000);
6009 pSMB->SetupCount = 1;
6010 pSMB->Reserved3 = 0;
6011 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
6012 byte_count = 3 /* pad */ + params + count;
6013 pSMB->DataCount = cpu_to_le16(count);
6014 pSMB->ParameterCount = cpu_to_le16(params);
6015 pSMB->TotalDataCount = pSMB->DataCount;
6016 pSMB->TotalParameterCount = pSMB->ParameterCount;
6017 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6018 pSMB->DataOffset = cpu_to_le16(offset);
6020 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6021 pSMB->Reserved4 = 0;
6022 inc_rfc1001_len(pSMB, byte_count);
6023 pSMB->ByteCount = cpu_to_le16(byte_count);
6025 cifs_fill_unix_set_info(data_offset, args);
6027 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
6029 cFYI(1, "Send error in Set Time (SetFileInfo) = %d", rc);
6031 /* Note: On -EAGAIN error only caller can retry on handle based calls
6032 since file handle passed in no longer valid */
6038 CIFSSMBUnixSetPathInfo(const int xid, struct cifs_tcon *tcon, char *fileName,
6039 const struct cifs_unix_set_info_args *args,
6040 const struct nls_table *nls_codepage, int remap)
6042 TRANSACTION2_SPI_REQ *pSMB = NULL;
6043 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6046 int bytes_returned = 0;
6047 FILE_UNIX_BASIC_INFO *data_offset;
6048 __u16 params, param_offset, offset, count, byte_count;
6050 cFYI(1, "In SetUID/GID/Mode");
6052 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6057 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6059 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6060 PATH_MAX, nls_codepage, remap);
6061 name_len++; /* trailing null */
6063 } else { /* BB improve the check for buffer overruns BB */
6064 name_len = strnlen(fileName, PATH_MAX);
6065 name_len++; /* trailing null */
6066 strncpy(pSMB->FileName, fileName, name_len);
6069 params = 6 + name_len;
6070 count = sizeof(FILE_UNIX_BASIC_INFO);
6071 pSMB->MaxParameterCount = cpu_to_le16(2);
6072 /* BB find max SMB PDU from sess structure BB */
6073 pSMB->MaxDataCount = cpu_to_le16(1000);
6074 pSMB->MaxSetupCount = 0;
6078 pSMB->Reserved2 = 0;
6079 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6080 InformationLevel) - 4;
6081 offset = param_offset + params;
6083 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6085 memset(data_offset, 0, count);
6086 pSMB->DataOffset = cpu_to_le16(offset);
6087 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6088 pSMB->SetupCount = 1;
6089 pSMB->Reserved3 = 0;
6090 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6091 byte_count = 3 /* pad */ + params + count;
6092 pSMB->ParameterCount = cpu_to_le16(params);
6093 pSMB->DataCount = cpu_to_le16(count);
6094 pSMB->TotalParameterCount = pSMB->ParameterCount;
6095 pSMB->TotalDataCount = pSMB->DataCount;
6096 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6097 pSMB->Reserved4 = 0;
6098 inc_rfc1001_len(pSMB, byte_count);
6100 cifs_fill_unix_set_info(data_offset, args);
6102 pSMB->ByteCount = cpu_to_le16(byte_count);
6103 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6104 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6106 cFYI(1, "SetPathInfo (perms) returned %d", rc);
6108 cifs_buf_release(pSMB);
6114 #ifdef CONFIG_CIFS_XATTR
6116 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6117 * function used by listxattr and getxattr type calls. When ea_name is set,
6118 * it looks for that attribute name and stuffs that value into the EAData
6119 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6120 * buffer. In both cases, the return value is either the length of the
6121 * resulting data or a negative error code. If EAData is a NULL pointer then
6122 * the data isn't copied to it, but the length is returned.
6125 CIFSSMBQAllEAs(const int xid, struct cifs_tcon *tcon,
6126 const unsigned char *searchName, const unsigned char *ea_name,
6127 char *EAData, size_t buf_size,
6128 const struct nls_table *nls_codepage, int remap)
6130 /* BB assumes one setup word */
6131 TRANSACTION2_QPI_REQ *pSMB = NULL;
6132 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6136 struct fealist *ea_response_data;
6137 struct fea *temp_fea;
6140 __u16 params, byte_count, data_offset;
6141 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
6143 cFYI(1, "In Query All EAs path %s", searchName);
6145 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6150 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6152 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6153 PATH_MAX, nls_codepage, remap);
6154 list_len++; /* trailing null */
6156 } else { /* BB improve the check for buffer overruns BB */
6157 list_len = strnlen(searchName, PATH_MAX);
6158 list_len++; /* trailing null */
6159 strncpy(pSMB->FileName, searchName, list_len);
6162 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
6163 pSMB->TotalDataCount = 0;
6164 pSMB->MaxParameterCount = cpu_to_le16(2);
6165 /* BB find exact max SMB PDU from sess structure BB */
6166 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
6167 pSMB->MaxSetupCount = 0;
6171 pSMB->Reserved2 = 0;
6172 pSMB->ParameterOffset = cpu_to_le16(offsetof(
6173 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
6174 pSMB->DataCount = 0;
6175 pSMB->DataOffset = 0;
6176 pSMB->SetupCount = 1;
6177 pSMB->Reserved3 = 0;
6178 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6179 byte_count = params + 1 /* pad */ ;
6180 pSMB->TotalParameterCount = cpu_to_le16(params);
6181 pSMB->ParameterCount = pSMB->TotalParameterCount;
6182 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6183 pSMB->Reserved4 = 0;
6184 inc_rfc1001_len(pSMB, byte_count);
6185 pSMB->ByteCount = cpu_to_le16(byte_count);
6187 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6188 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6190 cFYI(1, "Send error in QueryAllEAs = %d", rc);
6195 /* BB also check enough total bytes returned */
6196 /* BB we need to improve the validity checking
6197 of these trans2 responses */
6199 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6200 if (rc || get_bcc(&pSMBr->hdr) < 4) {
6201 rc = -EIO; /* bad smb */
6205 /* check that length of list is not more than bcc */
6206 /* check that each entry does not go beyond length
6208 /* check that each element of each entry does not
6209 go beyond end of list */
6210 /* validate_trans2_offsets() */
6211 /* BB check if start of smb + data_offset > &bcc+ bcc */
6213 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6214 ea_response_data = (struct fealist *)
6215 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6217 list_len = le32_to_cpu(ea_response_data->list_len);
6218 cFYI(1, "ea length %d", list_len);
6219 if (list_len <= 8) {
6220 cFYI(1, "empty EA list returned from server");
6224 /* make sure list_len doesn't go past end of SMB */
6225 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
6226 if ((char *)ea_response_data + list_len > end_of_smb) {
6227 cFYI(1, "EA list appears to go beyond SMB");
6232 /* account for ea list len */
6234 temp_fea = ea_response_data->list;
6235 temp_ptr = (char *)temp_fea;
6236 while (list_len > 0) {
6237 unsigned int name_len;
6242 /* make sure we can read name_len and value_len */
6244 cFYI(1, "EA entry goes beyond length of list");
6249 name_len = temp_fea->name_len;
6250 value_len = le16_to_cpu(temp_fea->value_len);
6251 list_len -= name_len + 1 + value_len;
6253 cFYI(1, "EA entry goes beyond length of list");
6259 if (ea_name_len == name_len &&
6260 memcmp(ea_name, temp_ptr, name_len) == 0) {
6261 temp_ptr += name_len + 1;
6265 if ((size_t)value_len > buf_size) {
6269 memcpy(EAData, temp_ptr, value_len);
6273 /* account for prefix user. and trailing null */
6274 rc += (5 + 1 + name_len);
6275 if (rc < (int) buf_size) {
6276 memcpy(EAData, "user.", 5);
6278 memcpy(EAData, temp_ptr, name_len);
6280 /* null terminate name */
6283 } else if (buf_size == 0) {
6284 /* skip copy - calc size only */
6286 /* stop before overrun buffer */
6291 temp_ptr += name_len + 1 + value_len;
6292 temp_fea = (struct fea *)temp_ptr;
6295 /* didn't find the named attribute */
6300 cifs_buf_release(pSMB);
6308 CIFSSMBSetEA(const int xid, struct cifs_tcon *tcon, const char *fileName,
6309 const char *ea_name, const void *ea_value,
6310 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6313 struct smb_com_transaction2_spi_req *pSMB = NULL;
6314 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6315 struct fealist *parm_data;
6318 int bytes_returned = 0;
6319 __u16 params, param_offset, byte_count, offset, count;
6321 cFYI(1, "In SetEA");
6323 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6328 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6330 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6331 PATH_MAX, nls_codepage, remap);
6332 name_len++; /* trailing null */
6334 } else { /* BB improve the check for buffer overruns BB */
6335 name_len = strnlen(fileName, PATH_MAX);
6336 name_len++; /* trailing null */
6337 strncpy(pSMB->FileName, fileName, name_len);
6340 params = 6 + name_len;
6342 /* done calculating parms using name_len of file name,
6343 now use name_len to calculate length of ea name
6344 we are going to create in the inode xattrs */
6345 if (ea_name == NULL)
6348 name_len = strnlen(ea_name, 255);
6350 count = sizeof(*parm_data) + ea_value_len + name_len;
6351 pSMB->MaxParameterCount = cpu_to_le16(2);
6352 /* BB find max SMB PDU from sess */
6353 pSMB->MaxDataCount = cpu_to_le16(1000);
6354 pSMB->MaxSetupCount = 0;
6358 pSMB->Reserved2 = 0;
6359 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6360 InformationLevel) - 4;
6361 offset = param_offset + params;
6362 pSMB->InformationLevel =
6363 cpu_to_le16(SMB_SET_FILE_EA);
6366 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6368 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6369 pSMB->DataOffset = cpu_to_le16(offset);
6370 pSMB->SetupCount = 1;
6371 pSMB->Reserved3 = 0;
6372 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6373 byte_count = 3 /* pad */ + params + count;
6374 pSMB->DataCount = cpu_to_le16(count);
6375 parm_data->list_len = cpu_to_le32(count);
6376 parm_data->list[0].EA_flags = 0;
6377 /* we checked above that name len is less than 255 */
6378 parm_data->list[0].name_len = (__u8)name_len;
6379 /* EA names are always ASCII */
6381 strncpy(parm_data->list[0].name, ea_name, name_len);
6382 parm_data->list[0].name[name_len] = 0;
6383 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6384 /* caller ensures that ea_value_len is less than 64K but
6385 we need to ensure that it fits within the smb */
6387 /*BB add length check to see if it would fit in
6388 negotiated SMB buffer size BB */
6389 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6391 memcpy(parm_data->list[0].name+name_len+1,
6392 ea_value, ea_value_len);
6394 pSMB->TotalDataCount = pSMB->DataCount;
6395 pSMB->ParameterCount = cpu_to_le16(params);
6396 pSMB->TotalParameterCount = pSMB->ParameterCount;
6397 pSMB->Reserved4 = 0;
6398 inc_rfc1001_len(pSMB, byte_count);
6399 pSMB->ByteCount = cpu_to_le16(byte_count);
6400 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6401 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6403 cFYI(1, "SetPathInfo (EA) returned %d", rc);
6405 cifs_buf_release(pSMB);
6414 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6416 * Years ago the kernel added a "dnotify" function for Samba server,
6417 * to allow network clients (such as Windows) to display updated
6418 * lists of files in directory listings automatically when
6419 * files are added by one user when another user has the
6420 * same directory open on their desktop. The Linux cifs kernel
6421 * client hooked into the kernel side of this interface for
6422 * the same reason, but ironically when the VFS moved from
6423 * "dnotify" to "inotify" it became harder to plug in Linux
6424 * network file system clients (the most obvious use case
6425 * for notify interfaces is when multiple users can update
6426 * the contents of the same directory - exactly what network
6427 * file systems can do) although the server (Samba) could
6428 * still use it. For the short term we leave the worker
6429 * function ifdeffed out (below) until inotify is fixed
6430 * in the VFS to make it easier to plug in network file
6431 * system clients. If inotify turns out to be permanently
6432 * incompatible for network fs clients, we could instead simply
6433 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6435 int CIFSSMBNotify(const int xid, struct cifs_tcon *tcon,
6436 const int notify_subdirs, const __u16 netfid,
6437 __u32 filter, struct file *pfile, int multishot,
6438 const struct nls_table *nls_codepage)
6441 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6442 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6443 struct dir_notify_req *dnotify_req;
6446 cFYI(1, "In CIFSSMBNotify for file handle %d", (int)netfid);
6447 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6452 pSMB->TotalParameterCount = 0 ;
6453 pSMB->TotalDataCount = 0;
6454 pSMB->MaxParameterCount = cpu_to_le32(2);
6455 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
6456 pSMB->MaxSetupCount = 4;
6458 pSMB->ParameterOffset = 0;
6459 pSMB->DataCount = 0;
6460 pSMB->DataOffset = 0;
6461 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6462 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6463 pSMB->ParameterCount = pSMB->TotalParameterCount;
6465 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6466 pSMB->Reserved2 = 0;
6467 pSMB->CompletionFilter = cpu_to_le32(filter);
6468 pSMB->Fid = netfid; /* file handle always le */
6469 pSMB->ByteCount = 0;
6471 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6472 (struct smb_hdr *)pSMBr, &bytes_returned,
6475 cFYI(1, "Error in Notify = %d", rc);
6477 /* Add file to outstanding requests */
6478 /* BB change to kmem cache alloc */
6479 dnotify_req = kmalloc(
6480 sizeof(struct dir_notify_req),
6483 dnotify_req->Pid = pSMB->hdr.Pid;
6484 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6485 dnotify_req->Mid = pSMB->hdr.Mid;
6486 dnotify_req->Tid = pSMB->hdr.Tid;
6487 dnotify_req->Uid = pSMB->hdr.Uid;
6488 dnotify_req->netfid = netfid;
6489 dnotify_req->pfile = pfile;
6490 dnotify_req->filter = filter;
6491 dnotify_req->multishot = multishot;
6492 spin_lock(&GlobalMid_Lock);
6493 list_add_tail(&dnotify_req->lhead,
6494 &GlobalDnotifyReqList);
6495 spin_unlock(&GlobalMid_Lock);
6499 cifs_buf_release(pSMB);
6502 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */