4 * Copyright (C) International Business Machines Corp., 2002,2006
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 different for reconnection purposes since we never want */
28 /* to reuse a stale file handle and the caller knows the file handle */
31 #include <linux/kernel.h>
32 #include <linux/vfs.h>
33 #include <linux/posix_acl_xattr.h>
34 #include <asm/uaccess.h>
37 #include "cifsproto.h"
38 #include "cifs_unicode.h"
39 #include "cifs_debug.h"
42 #ifdef CONFIG_CIFS_POSIX
47 {CIFS_PROT, "\2NT LM 0.12"},
48 {CIFS_PROT, "\2POSIX 2"},
56 {CIFS_PROT, "\2NT LM 0.12"},
62 /* Mark as invalid, all open files on tree connections since they
63 were closed when session to server was lost */
64 static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
66 struct cifsFileInfo *open_file = NULL;
67 struct list_head * tmp;
68 struct list_head * tmp1;
70 /* list all files open on tree connection and mark them invalid */
71 write_lock(&GlobalSMBSeslock);
72 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
73 open_file = list_entry(tmp,struct cifsFileInfo, tlist);
75 open_file->invalidHandle = TRUE;
78 write_unlock(&GlobalSMBSeslock);
79 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
83 /* If the return code is zero, this function must fill in request_buf pointer */
85 small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
86 void **request_buf /* returned */)
90 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
91 check for tcp and smb session status done differently
92 for those three - in the calling routine */
94 if(tcon->tidStatus == CifsExiting) {
95 /* only tree disconnect, open, and write,
96 (and ulogoff which does not have tcon)
97 are allowed as we start force umount */
98 if((smb_command != SMB_COM_WRITE_ANDX) &&
99 (smb_command != SMB_COM_OPEN_ANDX) &&
100 (smb_command != SMB_COM_TREE_DISCONNECT)) {
101 cFYI(1,("can not send cmd %d while umounting",
106 if((tcon->ses) && (tcon->ses->status != CifsExiting) &&
107 (tcon->ses->server)){
108 struct nls_table *nls_codepage;
109 /* Give Demultiplex thread up to 10 seconds to
110 reconnect, should be greater than cifs socket
111 timeout which is 7 seconds */
112 while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
113 wait_event_interruptible_timeout(tcon->ses->server->response_q,
114 (tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
115 if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
116 /* on "soft" mounts we wait once */
117 if((tcon->retry == FALSE) ||
118 (tcon->ses->status == CifsExiting)) {
119 cFYI(1,("gave up waiting on reconnect in smb_init"));
121 } /* else "hard" mount - keep retrying
122 until process is killed or server
123 comes back on-line */
124 } else /* TCP session is reestablished now */
129 nls_codepage = load_nls_default();
130 /* need to prevent multiple threads trying to
131 simultaneously reconnect the same SMB session */
132 down(&tcon->ses->sesSem);
133 if(tcon->ses->status == CifsNeedReconnect)
134 rc = cifs_setup_session(0, tcon->ses,
136 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
137 mark_open_files_invalid(tcon);
138 rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon
140 up(&tcon->ses->sesSem);
141 /* BB FIXME add code to check if wsize needs
142 update due to negotiated smb buffer size
145 atomic_inc(&tconInfoReconnectCount);
147 cFYI(1, ("reconnect tcon rc = %d", rc));
148 /* Removed call to reopen open files here -
149 it is safer (and faster) to reopen files
150 one at a time as needed in read and write */
152 /* Check if handle based operation so we
153 know whether we can continue or not without
154 returning to caller to reset file handle */
155 switch(smb_command) {
156 case SMB_COM_READ_ANDX:
157 case SMB_COM_WRITE_ANDX:
159 case SMB_COM_FIND_CLOSE2:
160 case SMB_COM_LOCKING_ANDX: {
161 unload_nls(nls_codepage);
166 up(&tcon->ses->sesSem);
168 unload_nls(nls_codepage);
177 *request_buf = cifs_small_buf_get();
178 if (*request_buf == NULL) {
179 /* BB should we add a retry in here if not a writepage? */
183 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,wct);
186 cifs_stats_inc(&tcon->num_smbs_sent);
191 #ifdef CONFIG_CIFS_EXPERIMENTAL
193 small_smb_init_no_tc(const int smb_command, const int wct,
194 struct cifsSesInfo *ses, void **request_buf)
197 struct smb_hdr * buffer;
199 rc = small_smb_init(smb_command, wct, NULL, request_buf);
203 buffer = (struct smb_hdr *)*request_buf;
204 buffer->Mid = GetNextMid(ses->server);
205 if (ses->capabilities & CAP_UNICODE)
206 buffer->Flags2 |= SMBFLG2_UNICODE;
207 if (ses->capabilities & CAP_STATUS32)
208 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
210 /* uid, tid can stay at zero as set in header assemble */
212 /* BB add support for turning on the signing when
213 this function is used after 1st of session setup requests */
217 #endif /* CONFIG_CIFS_EXPERIMENTAL */
219 /* If the return code is zero, this function must fill in request_buf pointer */
221 smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
222 void **request_buf /* returned */ ,
223 void **response_buf /* returned */ )
227 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
228 check for tcp and smb session status done differently
229 for those three - in the calling routine */
231 if(tcon->tidStatus == CifsExiting) {
232 /* only tree disconnect, open, and write,
233 (and ulogoff which does not have tcon)
234 are allowed as we start force umount */
235 if((smb_command != SMB_COM_WRITE_ANDX) &&
236 (smb_command != SMB_COM_OPEN_ANDX) &&
237 (smb_command != SMB_COM_TREE_DISCONNECT)) {
238 cFYI(1,("can not send cmd %d while umounting",
244 if((tcon->ses) && (tcon->ses->status != CifsExiting) &&
245 (tcon->ses->server)){
246 struct nls_table *nls_codepage;
247 /* Give Demultiplex thread up to 10 seconds to
248 reconnect, should be greater than cifs socket
249 timeout which is 7 seconds */
250 while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
251 wait_event_interruptible_timeout(tcon->ses->server->response_q,
252 (tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
253 if(tcon->ses->server->tcpStatus ==
255 /* on "soft" mounts we wait once */
256 if((tcon->retry == FALSE) ||
257 (tcon->ses->status == CifsExiting)) {
258 cFYI(1,("gave up waiting on reconnect in smb_init"));
260 } /* else "hard" mount - keep retrying
261 until process is killed or server
263 } else /* TCP session is reestablished now */
268 nls_codepage = load_nls_default();
269 /* need to prevent multiple threads trying to
270 simultaneously reconnect the same SMB session */
271 down(&tcon->ses->sesSem);
272 if(tcon->ses->status == CifsNeedReconnect)
273 rc = cifs_setup_session(0, tcon->ses,
275 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
276 mark_open_files_invalid(tcon);
277 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
279 up(&tcon->ses->sesSem);
280 /* BB FIXME add code to check if wsize needs
281 update due to negotiated smb buffer size
284 atomic_inc(&tconInfoReconnectCount);
286 cFYI(1, ("reconnect tcon rc = %d", rc));
287 /* Removed call to reopen open files here -
288 it is safer (and faster) to reopen files
289 one at a time as needed in read and write */
291 /* Check if handle based operation so we
292 know whether we can continue or not without
293 returning to caller to reset file handle */
294 switch(smb_command) {
295 case SMB_COM_READ_ANDX:
296 case SMB_COM_WRITE_ANDX:
298 case SMB_COM_FIND_CLOSE2:
299 case SMB_COM_LOCKING_ANDX: {
300 unload_nls(nls_codepage);
305 up(&tcon->ses->sesSem);
307 unload_nls(nls_codepage);
316 *request_buf = cifs_buf_get();
317 if (*request_buf == NULL) {
318 /* BB should we add a retry in here if not a writepage? */
321 /* Although the original thought was we needed the response buf for */
322 /* potential retries of smb operations it turns out we can determine */
323 /* from the mid flags when the request buffer can be resent without */
324 /* having to use a second distinct buffer for the response */
325 *response_buf = *request_buf;
327 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
331 cifs_stats_inc(&tcon->num_smbs_sent);
336 static int validate_t2(struct smb_t2_rsp * pSMB)
342 /* check for plausible wct, bcc and t2 data and parm sizes */
343 /* check for parm and data offset going beyond end of smb */
344 if(pSMB->hdr.WordCount >= 10) {
345 if((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
346 (le16_to_cpu(pSMB->t2_rsp.DataOffset) <= 1024)) {
347 /* check that bcc is at least as big as parms + data */
348 /* check that bcc is less than negotiated smb buffer */
349 total_size = le16_to_cpu(pSMB->t2_rsp.ParameterCount);
350 if(total_size < 512) {
351 total_size+=le16_to_cpu(pSMB->t2_rsp.DataCount);
352 /* BCC le converted in SendReceive */
353 pBCC = (pSMB->hdr.WordCount * 2) +
354 sizeof(struct smb_hdr) +
356 if((total_size <= (*(u16 *)pBCC)) &&
358 CIFSMaxBufSize+MAX_CIFS_HDR_SIZE)) {
365 cifs_dump_mem("Invalid transact2 SMB: ",(char *)pSMB,
366 sizeof(struct smb_t2_rsp) + 16);
370 CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
373 NEGOTIATE_RSP *pSMBr;
376 struct TCP_Server_Info * server;
380 server = ses->server;
385 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
386 (void **) &pSMB, (void **) &pSMBr);
389 pSMB->hdr.Mid = GetNextMid(server);
390 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
391 if (extended_security)
392 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
394 count = strlen(protocols[0].name) + 1;
395 strncpy(pSMB->DialectsArray, protocols[0].name, 30);
396 /* null guaranteed to be at end of source and target buffers anyway */
398 pSMB->hdr.smb_buf_length += count;
399 pSMB->ByteCount = cpu_to_le16(count);
401 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
402 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
404 server->secMode = pSMBr->SecurityMode;
405 if((server->secMode & SECMODE_USER) == 0)
406 cFYI(1,("share mode security"));
407 server->secType = NTLM; /* BB override default for
408 NTLMv2 or kerberos v5 */
409 /* one byte - no need to convert this or EncryptionKeyLen
410 from little endian */
411 server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
412 /* probably no need to store and check maxvcs */
414 min(le32_to_cpu(pSMBr->MaxBufferSize),
415 (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
416 server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
417 cFYI(0, ("Max buf = %d", ses->server->maxBuf));
418 GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
419 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
420 server->timeZone = le16_to_cpu(pSMBr->ServerTimeZone);
421 /* BB with UTC do we ever need to be using srvr timezone? */
422 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
423 memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
424 CIFS_CRYPTO_KEY_SIZE);
425 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
426 && (pSMBr->EncryptionKeyLength == 0)) {
427 /* decode security blob */
431 /* BB might be helpful to save off the domain of server here */
433 if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
434 (server->capabilities & CAP_EXTENDED_SECURITY)) {
435 count = pSMBr->ByteCount;
438 else if (count == 16) {
439 server->secType = RawNTLMSSP;
440 if (server->socketUseCount.counter > 1) {
442 (server->server_GUID,
443 pSMBr->u.extended_response.
445 cFYI(1, ("server UID changed"));
453 memcpy(server->server_GUID,
454 pSMBr->u.extended_response.
457 rc = decode_negTokenInit(pSMBr->u.
463 /* BB Need to fill struct for sessetup here */
470 server->capabilities &= ~CAP_EXTENDED_SECURITY;
471 if(sign_CIFS_PDUs == FALSE) {
472 if(server->secMode & SECMODE_SIGN_REQUIRED)
474 ("Server requires /proc/fs/cifs/PacketSigningEnabled"));
475 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
476 } else if(sign_CIFS_PDUs == 1) {
477 if((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
478 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
483 cifs_buf_release(pSMB);
488 CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
490 struct smb_hdr *smb_buffer;
491 struct smb_hdr *smb_buffer_response; /* BB removeme BB */
495 cFYI(1, ("In tree disconnect"));
497 * If last user of the connection and
498 * connection alive - disconnect it
499 * If this is the last connection on the server session disconnect it
500 * (and inside session disconnect we should check if tcp socket needs
501 * to be freed and kernel thread woken up).
504 down(&tcon->tconSem);
508 atomic_dec(&tcon->useCount);
509 if (atomic_read(&tcon->useCount) > 0) {
514 /* No need to return error on this operation if tid invalidated and
515 closed on server already e.g. due to tcp session crashing */
516 if(tcon->tidStatus == CifsNeedReconnect) {
521 if((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
525 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
526 (void **)&smb_buffer);
531 smb_buffer_response = smb_buffer; /* BB removeme BB */
533 rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
536 cFYI(1, ("Tree disconnect failed %d", rc));
539 cifs_small_buf_release(smb_buffer);
542 /* No need to return error on this operation if tid invalidated and
543 closed on server already e.g. due to tcp session crashing */
551 CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
553 struct smb_hdr *smb_buffer_response;
554 LOGOFF_ANDX_REQ *pSMB;
558 cFYI(1, ("In SMBLogoff for session disconnect"));
564 atomic_dec(&ses->inUse);
565 if (atomic_read(&ses->inUse) > 0) {
569 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
575 smb_buffer_response = (struct smb_hdr *)pSMB; /* BB removeme BB */
578 pSMB->hdr.Mid = GetNextMid(ses->server);
580 if(ses->server->secMode &
581 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
582 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
585 pSMB->hdr.Uid = ses->Suid;
587 pSMB->AndXCommand = 0xFF;
588 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
589 smb_buffer_response, &length, 0);
591 atomic_dec(&ses->server->socketUseCount);
592 if (atomic_read(&ses->server->socketUseCount) == 0) {
593 spin_lock(&GlobalMid_Lock);
594 ses->server->tcpStatus = CifsExiting;
595 spin_unlock(&GlobalMid_Lock);
600 cifs_small_buf_release(pSMB);
602 /* if session dead then we do not need to do ulogoff,
603 since server closed smb session, no sense reporting
611 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
612 const struct nls_table *nls_codepage, int remap)
614 DELETE_FILE_REQ *pSMB = NULL;
615 DELETE_FILE_RSP *pSMBr = NULL;
621 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
626 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
628 cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
629 PATH_MAX, nls_codepage, remap);
630 name_len++; /* trailing null */
632 } else { /* BB improve check for buffer overruns BB */
633 name_len = strnlen(fileName, PATH_MAX);
634 name_len++; /* trailing null */
635 strncpy(pSMB->fileName, fileName, name_len);
637 pSMB->SearchAttributes =
638 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
639 pSMB->BufferFormat = 0x04;
640 pSMB->hdr.smb_buf_length += name_len + 1;
641 pSMB->ByteCount = cpu_to_le16(name_len + 1);
642 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
643 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
644 cifs_stats_inc(&tcon->num_deletes);
646 cFYI(1, ("Error in RMFile = %d", rc));
649 cifs_buf_release(pSMB);
657 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
658 const struct nls_table *nls_codepage, int remap)
660 DELETE_DIRECTORY_REQ *pSMB = NULL;
661 DELETE_DIRECTORY_RSP *pSMBr = NULL;
666 cFYI(1, ("In CIFSSMBRmDir"));
668 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
673 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
674 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
675 PATH_MAX, nls_codepage, remap);
676 name_len++; /* trailing null */
678 } else { /* BB improve check for buffer overruns BB */
679 name_len = strnlen(dirName, PATH_MAX);
680 name_len++; /* trailing null */
681 strncpy(pSMB->DirName, dirName, name_len);
684 pSMB->BufferFormat = 0x04;
685 pSMB->hdr.smb_buf_length += name_len + 1;
686 pSMB->ByteCount = cpu_to_le16(name_len + 1);
687 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
688 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
689 cifs_stats_inc(&tcon->num_rmdirs);
691 cFYI(1, ("Error in RMDir = %d", rc));
694 cifs_buf_release(pSMB);
701 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
702 const char *name, const struct nls_table *nls_codepage, int remap)
705 CREATE_DIRECTORY_REQ *pSMB = NULL;
706 CREATE_DIRECTORY_RSP *pSMBr = NULL;
710 cFYI(1, ("In CIFSSMBMkDir"));
712 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
717 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
718 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
719 PATH_MAX, nls_codepage, remap);
720 name_len++; /* trailing null */
722 } else { /* BB improve check for buffer overruns BB */
723 name_len = strnlen(name, PATH_MAX);
724 name_len++; /* trailing null */
725 strncpy(pSMB->DirName, name, name_len);
728 pSMB->BufferFormat = 0x04;
729 pSMB->hdr.smb_buf_length += name_len + 1;
730 pSMB->ByteCount = cpu_to_le16(name_len + 1);
731 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
732 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
733 cifs_stats_inc(&tcon->num_mkdirs);
735 cFYI(1, ("Error in Mkdir = %d", rc));
738 cifs_buf_release(pSMB);
744 static __u16 convert_disposition(int disposition)
748 switch (disposition) {
750 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
753 ofun = SMBOPEN_OAPPEND;
756 ofun = SMBOPEN_OCREATE;
759 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
762 ofun = SMBOPEN_OTRUNC;
764 case FILE_OVERWRITE_IF:
765 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
768 cFYI(1,("unknown disposition %d",disposition));
769 ofun = SMBOPEN_OAPPEND; /* regular open */
775 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
776 const char *fileName, const int openDisposition,
777 const int access_flags, const int create_options, __u16 * netfid,
778 int *pOplock, FILE_ALL_INFO * pfile_info,
779 const struct nls_table *nls_codepage, int remap)
782 OPENX_REQ *pSMB = NULL;
783 OPENX_RSP *pSMBr = NULL;
789 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
794 pSMB->AndXCommand = 0xFF; /* none */
796 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
797 count = 1; /* account for one byte pad to word boundary */
799 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
800 fileName, PATH_MAX, nls_codepage, remap);
801 name_len++; /* trailing null */
803 } else { /* BB improve check for buffer overruns BB */
804 count = 0; /* no pad */
805 name_len = strnlen(fileName, PATH_MAX);
806 name_len++; /* trailing null */
807 strncpy(pSMB->fileName, fileName, name_len);
809 if (*pOplock & REQ_OPLOCK)
810 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
811 else if (*pOplock & REQ_BATCHOPLOCK) {
812 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
814 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
815 /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
821 pSMB->Mode = cpu_to_le16(2);
822 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
823 /* set file as system file if special file such
824 as fifo and server expecting SFU style and
825 no Unix extensions */
827 if(create_options & CREATE_OPTION_SPECIAL)
828 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
830 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); /* BB FIXME */
832 /* if ((omode & S_IWUGO) == 0)
833 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
834 /* Above line causes problems due to vfs splitting create into two
835 pieces - need to set mode after file created not while it is
839 /* pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK); */
840 /* BB FIXME END BB */
842 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
843 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
845 pSMB->hdr.smb_buf_length += count;
847 pSMB->ByteCount = cpu_to_le16(count);
848 /* long_op set to 1 to allow for oplock break timeouts */
849 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
850 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
851 cifs_stats_inc(&tcon->num_opens);
853 cFYI(1, ("Error in Open = %d", rc));
855 /* BB verify if wct == 15 */
857 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field BB */
859 *netfid = pSMBr->Fid; /* cifs fid stays in le */
860 /* Let caller know file was created so we can set the mode. */
861 /* Do we care about the CreateAction in any other cases? */
863 /* if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
864 *pOplock |= CIFS_CREATE_ACTION; */
868 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
869 pfile_info->LastAccessTime = 0; /* BB fixme */
870 pfile_info->LastWriteTime = 0; /* BB fixme */
871 pfile_info->ChangeTime = 0; /* BB fixme */
872 pfile_info->Attributes =
873 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
874 /* the file_info buf is endian converted by caller */
875 pfile_info->AllocationSize =
876 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
877 pfile_info->EndOfFile = pfile_info->AllocationSize;
878 pfile_info->NumberOfLinks = cpu_to_le32(1);
882 cifs_buf_release(pSMB);
889 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
890 const char *fileName, const int openDisposition,
891 const int access_flags, const int create_options, __u16 * netfid,
892 int *pOplock, FILE_ALL_INFO * pfile_info,
893 const struct nls_table *nls_codepage, int remap)
896 OPEN_REQ *pSMB = NULL;
897 OPEN_RSP *pSMBr = NULL;
903 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
908 pSMB->AndXCommand = 0xFF; /* none */
910 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
911 count = 1; /* account for one byte pad to word boundary */
913 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
914 fileName, PATH_MAX, nls_codepage, remap);
915 name_len++; /* trailing null */
917 pSMB->NameLength = cpu_to_le16(name_len);
918 } else { /* BB improve check for buffer overruns BB */
919 count = 0; /* no pad */
920 name_len = strnlen(fileName, PATH_MAX);
921 name_len++; /* trailing null */
922 pSMB->NameLength = cpu_to_le16(name_len);
923 strncpy(pSMB->fileName, fileName, name_len);
925 if (*pOplock & REQ_OPLOCK)
926 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
927 else if (*pOplock & REQ_BATCHOPLOCK) {
928 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
930 pSMB->DesiredAccess = cpu_to_le32(access_flags);
931 pSMB->AllocationSize = 0;
932 /* set file as system file if special file such
933 as fifo and server expecting SFU style and
934 no Unix extensions */
935 if(create_options & CREATE_OPTION_SPECIAL)
936 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
938 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
939 /* XP does not handle ATTR_POSIX_SEMANTICS */
940 /* but it helps speed up case sensitive checks for other
941 servers such as Samba */
942 if (tcon->ses->capabilities & CAP_UNIX)
943 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
945 /* if ((omode & S_IWUGO) == 0)
946 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
947 /* Above line causes problems due to vfs splitting create into two
948 pieces - need to set mode after file created not while it is
950 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
951 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
952 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
953 /* BB Expirement with various impersonation levels and verify */
954 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
955 pSMB->SecurityFlags =
956 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
959 pSMB->hdr.smb_buf_length += count;
961 pSMB->ByteCount = cpu_to_le16(count);
962 /* long_op set to 1 to allow for oplock break timeouts */
963 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
964 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
965 cifs_stats_inc(&tcon->num_opens);
967 cFYI(1, ("Error in Open = %d", rc));
969 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
970 *netfid = pSMBr->Fid; /* cifs fid stays in le */
971 /* Let caller know file was created so we can set the mode. */
972 /* Do we care about the CreateAction in any other cases? */
973 if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
974 *pOplock |= CIFS_CREATE_ACTION;
976 memcpy((char *)pfile_info,(char *)&pSMBr->CreationTime,
977 36 /* CreationTime to Attributes */);
978 /* the file_info buf is endian converted by caller */
979 pfile_info->AllocationSize = pSMBr->AllocationSize;
980 pfile_info->EndOfFile = pSMBr->EndOfFile;
981 pfile_info->NumberOfLinks = cpu_to_le32(1);
985 cifs_buf_release(pSMB);
992 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
993 const int netfid, const unsigned int count,
994 const __u64 lseek, unsigned int *nbytes, char **buf,
998 READ_REQ *pSMB = NULL;
999 READ_RSP *pSMBr = NULL;
1000 char *pReadData = NULL;
1002 int resp_buf_type = 0;
1005 cFYI(1,("Reading %d bytes on fid %d",count,netfid));
1006 if(tcon->ses->capabilities & CAP_LARGE_FILES)
1009 wct = 10; /* old style read */
1012 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1016 /* tcon and ses pointer are checked in smb_init */
1017 if (tcon->ses->server == NULL)
1018 return -ECONNABORTED;
1020 pSMB->AndXCommand = 0xFF; /* none */
1022 pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
1024 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
1025 else if((lseek >> 32) > 0) /* can not handle this big offset for old */
1028 pSMB->Remaining = 0;
1029 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1030 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1032 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1034 /* old style read */
1035 struct smb_com_readx_req * pSMBW =
1036 (struct smb_com_readx_req *)pSMB;
1037 pSMBW->ByteCount = 0;
1040 iov[0].iov_base = (char *)pSMB;
1041 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1042 rc = SendReceive2(xid, tcon->ses, iov,
1045 cifs_stats_inc(&tcon->num_reads);
1046 pSMBr = (READ_RSP *)iov[0].iov_base;
1048 cERROR(1, ("Send error in read = %d", rc));
1050 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1051 data_length = data_length << 16;
1052 data_length += le16_to_cpu(pSMBr->DataLength);
1053 *nbytes = data_length;
1055 /*check that DataLength would not go beyond end of SMB */
1056 if ((data_length > CIFSMaxBufSize)
1057 || (data_length > count)) {
1058 cFYI(1,("bad length %d for count %d",data_length,count));
1062 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1063 le16_to_cpu(pSMBr->DataOffset);
1064 /* if(rc = copy_to_user(buf, pReadData, data_length)) {
1065 cERROR(1,("Faulting on read rc = %d",rc));
1067 }*/ /* can not use copy_to_user when using page cache*/
1069 memcpy(*buf,pReadData,data_length);
1073 cifs_small_buf_release(pSMB);
1075 if(resp_buf_type == CIFS_SMALL_BUFFER)
1076 cifs_small_buf_release(iov[0].iov_base);
1077 else if(resp_buf_type == CIFS_LARGE_BUFFER)
1078 cifs_buf_release(iov[0].iov_base);
1079 } else /* return buffer to caller to free */ /* BB FIXME how do we tell caller if it is not a large buffer */ {
1080 *buf = iov[0].iov_base;
1081 if(resp_buf_type == CIFS_SMALL_BUFFER)
1082 *pbuf_type = CIFS_SMALL_BUFFER;
1083 else if(resp_buf_type == CIFS_LARGE_BUFFER)
1084 *pbuf_type = CIFS_LARGE_BUFFER;
1087 /* Note: On -EAGAIN error only caller can retry on handle based calls
1088 since file handle passed in no longer valid */
1094 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
1095 const int netfid, const unsigned int count,
1096 const __u64 offset, unsigned int *nbytes, const char *buf,
1097 const char __user * ubuf, const int long_op)
1100 WRITE_REQ *pSMB = NULL;
1101 WRITE_RSP *pSMBr = NULL;
1102 int bytes_returned, wct;
1106 /* cFYI(1,("write at %lld %d bytes",offset,count));*/
1107 if(tcon->ses == NULL)
1108 return -ECONNABORTED;
1110 if(tcon->ses->capabilities & CAP_LARGE_FILES)
1115 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1119 /* tcon and ses pointer are checked in smb_init */
1120 if (tcon->ses->server == NULL)
1121 return -ECONNABORTED;
1123 pSMB->AndXCommand = 0xFF; /* none */
1125 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1127 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1128 else if((offset >> 32) > 0) /* can not handle this big offset for old */
1131 pSMB->Reserved = 0xFFFFFFFF;
1132 pSMB->WriteMode = 0;
1133 pSMB->Remaining = 0;
1135 /* Can increase buffer size if buffer is big enough in some cases - ie we
1136 can send more if LARGE_WRITE_X capability returned by the server and if
1137 our buffer is big enough or if we convert to iovecs on socket writes
1138 and eliminate the copy to the CIFS buffer */
1139 if(tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1140 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1142 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1146 if (bytes_sent > count)
1149 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
1151 memcpy(pSMB->Data,buf,bytes_sent);
1153 if(copy_from_user(pSMB->Data,ubuf,bytes_sent)) {
1154 cifs_buf_release(pSMB);
1157 } else if (count != 0) {
1159 cifs_buf_release(pSMB);
1161 } /* else setting file size with write of zero bytes */
1163 byte_count = bytes_sent + 1; /* pad */
1164 else /* wct == 12 */ {
1165 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1167 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1168 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1169 pSMB->hdr.smb_buf_length += byte_count;
1172 pSMB->ByteCount = cpu_to_le16(byte_count);
1173 else { /* old style write has byte count 4 bytes earlier so 4 bytes pad */
1174 struct smb_com_writex_req * pSMBW =
1175 (struct smb_com_writex_req *)pSMB;
1176 pSMBW->ByteCount = cpu_to_le16(byte_count);
1179 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1180 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1181 cifs_stats_inc(&tcon->num_writes);
1183 cFYI(1, ("Send error in write = %d", rc));
1186 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1187 *nbytes = (*nbytes) << 16;
1188 *nbytes += le16_to_cpu(pSMBr->Count);
1191 cifs_buf_release(pSMB);
1193 /* Note: On -EAGAIN error only caller can retry on handle based calls
1194 since file handle passed in no longer valid */
1200 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
1201 const int netfid, const unsigned int count,
1202 const __u64 offset, unsigned int *nbytes, struct kvec *iov,
1203 int n_vec, const int long_op)
1206 WRITE_REQ *pSMB = NULL;
1209 int resp_buf_type = 0;
1211 cFYI(1,("write2 at %lld %d bytes", (long long)offset, count));
1213 if(tcon->ses->capabilities & CAP_LARGE_FILES)
1217 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1220 /* tcon and ses pointer are checked in smb_init */
1221 if (tcon->ses->server == NULL)
1222 return -ECONNABORTED;
1224 pSMB->AndXCommand = 0xFF; /* none */
1226 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1228 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1229 else if((offset >> 32) > 0) /* can not handle this big offset for old */
1231 pSMB->Reserved = 0xFFFFFFFF;
1232 pSMB->WriteMode = 0;
1233 pSMB->Remaining = 0;
1236 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
1238 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1239 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1240 smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1242 pSMB->hdr.smb_buf_length += count+1;
1243 else /* wct == 12 */
1244 pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
1246 pSMB->ByteCount = cpu_to_le16(count + 1);
1247 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1248 struct smb_com_writex_req * pSMBW =
1249 (struct smb_com_writex_req *)pSMB;
1250 pSMBW->ByteCount = cpu_to_le16(count + 5);
1252 iov[0].iov_base = pSMB;
1254 iov[0].iov_len = smb_hdr_len + 4;
1255 else /* wct == 12 pad bigger by four bytes */
1256 iov[0].iov_len = smb_hdr_len + 8;
1259 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
1261 cifs_stats_inc(&tcon->num_writes);
1263 cFYI(1, ("Send error Write2 = %d", rc));
1265 } else if(resp_buf_type == 0) {
1266 /* presumably this can not happen, but best to be safe */
1270 WRITE_RSP * pSMBr = (WRITE_RSP *)iov[0].iov_base;
1271 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1272 *nbytes = (*nbytes) << 16;
1273 *nbytes += le16_to_cpu(pSMBr->Count);
1276 cifs_small_buf_release(pSMB);
1277 if(resp_buf_type == CIFS_SMALL_BUFFER)
1278 cifs_small_buf_release(iov[0].iov_base);
1279 else if(resp_buf_type == CIFS_LARGE_BUFFER)
1280 cifs_buf_release(iov[0].iov_base);
1282 /* Note: On -EAGAIN error only caller can retry on handle based calls
1283 since file handle passed in no longer valid */
1290 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1291 const __u16 smb_file_id, const __u64 len,
1292 const __u64 offset, const __u32 numUnlock,
1293 const __u32 numLock, const __u8 lockType, const int waitFlag)
1296 LOCK_REQ *pSMB = NULL;
1297 LOCK_RSP *pSMBr = NULL;
1302 cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
1303 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1308 pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
1310 if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1311 timeout = -1; /* no response expected */
1313 } else if (waitFlag == TRUE) {
1314 timeout = 3; /* blocking operation, no timeout */
1315 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1320 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1321 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1322 pSMB->LockType = lockType;
1323 pSMB->AndXCommand = 0xFF; /* none */
1324 pSMB->Fid = smb_file_id; /* netfid stays le */
1326 if((numLock != 0) || (numUnlock != 0)) {
1327 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1328 /* BB where to store pid high? */
1329 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1330 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1331 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1332 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1333 count = sizeof(LOCKING_ANDX_RANGE);
1338 pSMB->hdr.smb_buf_length += count;
1339 pSMB->ByteCount = cpu_to_le16(count);
1341 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1342 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1343 cifs_stats_inc(&tcon->num_locks);
1345 cFYI(1, ("Send error in Lock = %d", rc));
1347 cifs_small_buf_release(pSMB);
1349 /* Note: On -EAGAIN error only caller can retry on handle based calls
1350 since file handle passed in no longer valid */
1355 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1358 CLOSE_REQ *pSMB = NULL;
1359 CLOSE_RSP *pSMBr = NULL;
1361 cFYI(1, ("In CIFSSMBClose"));
1363 /* do not retry on dead session on close */
1364 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1370 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
1372 pSMB->FileID = (__u16) smb_file_id;
1373 pSMB->LastWriteTime = 0;
1374 pSMB->ByteCount = 0;
1375 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1376 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1377 cifs_stats_inc(&tcon->num_closes);
1380 /* EINTR is expected when user ctl-c to kill app */
1381 cERROR(1, ("Send error in Close = %d", rc));
1385 cifs_small_buf_release(pSMB);
1387 /* Since session is dead, file will be closed on server already */
1395 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1396 const char *fromName, const char *toName,
1397 const struct nls_table *nls_codepage, int remap)
1400 RENAME_REQ *pSMB = NULL;
1401 RENAME_RSP *pSMBr = NULL;
1403 int name_len, name_len2;
1406 cFYI(1, ("In CIFSSMBRename"));
1408 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1413 pSMB->BufferFormat = 0x04;
1414 pSMB->SearchAttributes =
1415 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1418 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1420 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1421 PATH_MAX, nls_codepage, remap);
1422 name_len++; /* trailing null */
1424 pSMB->OldFileName[name_len] = 0x04; /* pad */
1425 /* protocol requires ASCII signature byte on Unicode string */
1426 pSMB->OldFileName[name_len + 1] = 0x00;
1428 cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1429 toName, PATH_MAX, nls_codepage, remap);
1430 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1431 name_len2 *= 2; /* convert to bytes */
1432 } else { /* BB improve the check for buffer overruns BB */
1433 name_len = strnlen(fromName, PATH_MAX);
1434 name_len++; /* trailing null */
1435 strncpy(pSMB->OldFileName, fromName, name_len);
1436 name_len2 = strnlen(toName, PATH_MAX);
1437 name_len2++; /* trailing null */
1438 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1439 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1440 name_len2++; /* trailing null */
1441 name_len2++; /* signature byte */
1444 count = 1 /* 1st signature byte */ + name_len + name_len2;
1445 pSMB->hdr.smb_buf_length += count;
1446 pSMB->ByteCount = cpu_to_le16(count);
1448 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1449 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1450 cifs_stats_inc(&tcon->num_renames);
1452 cFYI(1, ("Send error in rename = %d", rc));
1455 cifs_buf_release(pSMB);
1463 int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
1464 int netfid, char * target_name,
1465 const struct nls_table * nls_codepage, int remap)
1467 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1468 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1469 struct set_file_rename * rename_info;
1471 char dummy_string[30];
1473 int bytes_returned = 0;
1475 __u16 params, param_offset, offset, count, byte_count;
1477 cFYI(1, ("Rename to File by handle"));
1478 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
1484 pSMB->MaxSetupCount = 0;
1488 pSMB->Reserved2 = 0;
1489 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1490 offset = param_offset + params;
1492 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1493 rename_info = (struct set_file_rename *) data_offset;
1494 pSMB->MaxParameterCount = cpu_to_le16(2);
1495 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1496 pSMB->SetupCount = 1;
1497 pSMB->Reserved3 = 0;
1498 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1499 byte_count = 3 /* pad */ + params;
1500 pSMB->ParameterCount = cpu_to_le16(params);
1501 pSMB->TotalParameterCount = pSMB->ParameterCount;
1502 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1503 pSMB->DataOffset = cpu_to_le16(offset);
1504 /* construct random name ".cifs_tmp<inodenum><mid>" */
1505 rename_info->overwrite = cpu_to_le32(1);
1506 rename_info->root_fid = 0;
1507 /* unicode only call */
1508 if(target_name == NULL) {
1509 sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
1510 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1511 dummy_string, 24, nls_codepage, remap);
1513 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1514 target_name, PATH_MAX, nls_codepage, remap);
1516 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
1517 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
1518 byte_count += count;
1519 pSMB->DataCount = cpu_to_le16(count);
1520 pSMB->TotalDataCount = pSMB->DataCount;
1522 pSMB->InformationLevel =
1523 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
1524 pSMB->Reserved4 = 0;
1525 pSMB->hdr.smb_buf_length += byte_count;
1526 pSMB->ByteCount = cpu_to_le16(byte_count);
1527 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
1528 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1529 cifs_stats_inc(&pTcon->num_t2renames);
1531 cFYI(1,("Send error in Rename (by file handle) = %d", rc));
1534 cifs_buf_release(pSMB);
1536 /* Note: On -EAGAIN error only caller can retry on handle based calls
1537 since file handle passed in no longer valid */
1543 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName,
1544 const __u16 target_tid, const char *toName, const int flags,
1545 const struct nls_table *nls_codepage, int remap)
1548 COPY_REQ *pSMB = NULL;
1549 COPY_RSP *pSMBr = NULL;
1551 int name_len, name_len2;
1554 cFYI(1, ("In CIFSSMBCopy"));
1556 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
1561 pSMB->BufferFormat = 0x04;
1562 pSMB->Tid2 = target_tid;
1564 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
1566 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1567 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
1568 fromName, PATH_MAX, nls_codepage,
1570 name_len++; /* trailing null */
1572 pSMB->OldFileName[name_len] = 0x04; /* pad */
1573 /* protocol requires ASCII signature byte on Unicode string */
1574 pSMB->OldFileName[name_len + 1] = 0x00;
1575 name_len2 = cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1576 toName, PATH_MAX, nls_codepage, remap);
1577 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1578 name_len2 *= 2; /* convert to bytes */
1579 } else { /* BB improve the check for buffer overruns BB */
1580 name_len = strnlen(fromName, PATH_MAX);
1581 name_len++; /* trailing null */
1582 strncpy(pSMB->OldFileName, fromName, name_len);
1583 name_len2 = strnlen(toName, PATH_MAX);
1584 name_len2++; /* trailing null */
1585 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1586 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1587 name_len2++; /* trailing null */
1588 name_len2++; /* signature byte */
1591 count = 1 /* 1st signature byte */ + name_len + name_len2;
1592 pSMB->hdr.smb_buf_length += count;
1593 pSMB->ByteCount = cpu_to_le16(count);
1595 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1596 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1598 cFYI(1, ("Send error in copy = %d with %d files copied",
1599 rc, le16_to_cpu(pSMBr->CopyCount)));
1602 cifs_buf_release(pSMB);
1611 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
1612 const char *fromName, const char *toName,
1613 const struct nls_table *nls_codepage)
1615 TRANSACTION2_SPI_REQ *pSMB = NULL;
1616 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1619 int name_len_target;
1621 int bytes_returned = 0;
1622 __u16 params, param_offset, offset, byte_count;
1624 cFYI(1, ("In Symlink Unix style"));
1626 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1631 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1633 cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
1634 /* find define for this maxpathcomponent */
1636 name_len++; /* trailing null */
1639 } else { /* BB improve the check for buffer overruns BB */
1640 name_len = strnlen(fromName, PATH_MAX);
1641 name_len++; /* trailing null */
1642 strncpy(pSMB->FileName, fromName, name_len);
1644 params = 6 + name_len;
1645 pSMB->MaxSetupCount = 0;
1649 pSMB->Reserved2 = 0;
1650 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1651 InformationLevel) - 4;
1652 offset = param_offset + params;
1654 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1655 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1657 cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
1658 /* find define for this maxpathcomponent */
1660 name_len_target++; /* trailing null */
1661 name_len_target *= 2;
1662 } else { /* BB improve the check for buffer overruns BB */
1663 name_len_target = strnlen(toName, PATH_MAX);
1664 name_len_target++; /* trailing null */
1665 strncpy(data_offset, toName, name_len_target);
1668 pSMB->MaxParameterCount = cpu_to_le16(2);
1669 /* BB find exact max on data count below from sess */
1670 pSMB->MaxDataCount = cpu_to_le16(1000);
1671 pSMB->SetupCount = 1;
1672 pSMB->Reserved3 = 0;
1673 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1674 byte_count = 3 /* pad */ + params + name_len_target;
1675 pSMB->DataCount = cpu_to_le16(name_len_target);
1676 pSMB->ParameterCount = cpu_to_le16(params);
1677 pSMB->TotalDataCount = pSMB->DataCount;
1678 pSMB->TotalParameterCount = pSMB->ParameterCount;
1679 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1680 pSMB->DataOffset = cpu_to_le16(offset);
1681 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
1682 pSMB->Reserved4 = 0;
1683 pSMB->hdr.smb_buf_length += byte_count;
1684 pSMB->ByteCount = cpu_to_le16(byte_count);
1685 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1686 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1687 cifs_stats_inc(&tcon->num_symlinks);
1690 ("Send error in SetPathInfo (create symlink) = %d",
1695 cifs_buf_release(pSMB);
1698 goto createSymLinkRetry;
1704 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1705 const char *fromName, const char *toName,
1706 const struct nls_table *nls_codepage, int remap)
1708 TRANSACTION2_SPI_REQ *pSMB = NULL;
1709 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1712 int name_len_target;
1714 int bytes_returned = 0;
1715 __u16 params, param_offset, offset, byte_count;
1717 cFYI(1, ("In Create Hard link Unix style"));
1718 createHardLinkRetry:
1719 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1724 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1725 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
1726 PATH_MAX, nls_codepage, remap);
1727 name_len++; /* trailing null */
1730 } else { /* BB improve the check for buffer overruns BB */
1731 name_len = strnlen(toName, PATH_MAX);
1732 name_len++; /* trailing null */
1733 strncpy(pSMB->FileName, toName, name_len);
1735 params = 6 + name_len;
1736 pSMB->MaxSetupCount = 0;
1740 pSMB->Reserved2 = 0;
1741 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1742 InformationLevel) - 4;
1743 offset = param_offset + params;
1745 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1746 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1748 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
1749 nls_codepage, remap);
1750 name_len_target++; /* trailing null */
1751 name_len_target *= 2;
1752 } else { /* BB improve the check for buffer overruns BB */
1753 name_len_target = strnlen(fromName, PATH_MAX);
1754 name_len_target++; /* trailing null */
1755 strncpy(data_offset, fromName, name_len_target);
1758 pSMB->MaxParameterCount = cpu_to_le16(2);
1759 /* BB find exact max on data count below from sess*/
1760 pSMB->MaxDataCount = cpu_to_le16(1000);
1761 pSMB->SetupCount = 1;
1762 pSMB->Reserved3 = 0;
1763 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1764 byte_count = 3 /* pad */ + params + name_len_target;
1765 pSMB->ParameterCount = cpu_to_le16(params);
1766 pSMB->TotalParameterCount = pSMB->ParameterCount;
1767 pSMB->DataCount = cpu_to_le16(name_len_target);
1768 pSMB->TotalDataCount = pSMB->DataCount;
1769 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1770 pSMB->DataOffset = cpu_to_le16(offset);
1771 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
1772 pSMB->Reserved4 = 0;
1773 pSMB->hdr.smb_buf_length += byte_count;
1774 pSMB->ByteCount = cpu_to_le16(byte_count);
1775 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1776 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1777 cifs_stats_inc(&tcon->num_hardlinks);
1779 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
1782 cifs_buf_release(pSMB);
1784 goto createHardLinkRetry;
1790 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1791 const char *fromName, const char *toName,
1792 const struct nls_table *nls_codepage, int remap)
1795 NT_RENAME_REQ *pSMB = NULL;
1796 RENAME_RSP *pSMBr = NULL;
1798 int name_len, name_len2;
1801 cFYI(1, ("In CIFSCreateHardLink"));
1802 winCreateHardLinkRetry:
1804 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
1809 pSMB->SearchAttributes =
1810 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1812 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
1813 pSMB->ClusterCount = 0;
1815 pSMB->BufferFormat = 0x04;
1817 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1819 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1820 PATH_MAX, nls_codepage, remap);
1821 name_len++; /* trailing null */
1823 pSMB->OldFileName[name_len] = 0; /* pad */
1824 pSMB->OldFileName[name_len + 1] = 0x04;
1826 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1827 toName, PATH_MAX, nls_codepage, remap);
1828 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1829 name_len2 *= 2; /* convert to bytes */
1830 } else { /* BB improve the check for buffer overruns BB */
1831 name_len = strnlen(fromName, PATH_MAX);
1832 name_len++; /* trailing null */
1833 strncpy(pSMB->OldFileName, fromName, name_len);
1834 name_len2 = strnlen(toName, PATH_MAX);
1835 name_len2++; /* trailing null */
1836 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1837 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1838 name_len2++; /* trailing null */
1839 name_len2++; /* signature byte */
1842 count = 1 /* string type byte */ + name_len + name_len2;
1843 pSMB->hdr.smb_buf_length += count;
1844 pSMB->ByteCount = cpu_to_le16(count);
1846 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1847 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1848 cifs_stats_inc(&tcon->num_hardlinks);
1850 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
1852 cifs_buf_release(pSMB);
1854 goto winCreateHardLinkRetry;
1860 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
1861 const unsigned char *searchName,
1862 char *symlinkinfo, const int buflen,
1863 const struct nls_table *nls_codepage)
1865 /* SMB_QUERY_FILE_UNIX_LINK */
1866 TRANSACTION2_QPI_REQ *pSMB = NULL;
1867 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1871 __u16 params, byte_count;
1873 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
1876 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1881 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1883 cifs_strtoUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
1884 /* find define for this maxpathcomponent */
1886 name_len++; /* trailing null */
1888 } else { /* BB improve the check for buffer overruns BB */
1889 name_len = strnlen(searchName, PATH_MAX);
1890 name_len++; /* trailing null */
1891 strncpy(pSMB->FileName, searchName, name_len);
1894 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1895 pSMB->TotalDataCount = 0;
1896 pSMB->MaxParameterCount = cpu_to_le16(2);
1897 /* BB find exact max data count below from sess structure BB */
1898 pSMB->MaxDataCount = cpu_to_le16(4000);
1899 pSMB->MaxSetupCount = 0;
1903 pSMB->Reserved2 = 0;
1904 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1905 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1906 pSMB->DataCount = 0;
1907 pSMB->DataOffset = 0;
1908 pSMB->SetupCount = 1;
1909 pSMB->Reserved3 = 0;
1910 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1911 byte_count = params + 1 /* pad */ ;
1912 pSMB->TotalParameterCount = cpu_to_le16(params);
1913 pSMB->ParameterCount = pSMB->TotalParameterCount;
1914 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
1915 pSMB->Reserved4 = 0;
1916 pSMB->hdr.smb_buf_length += byte_count;
1917 pSMB->ByteCount = cpu_to_le16(byte_count);
1919 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1920 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1922 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
1924 /* decode response */
1926 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1927 if (rc || (pSMBr->ByteCount < 2))
1928 /* BB also check enough total bytes returned */
1929 rc = -EIO; /* bad smb */
1931 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1932 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
1934 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1935 name_len = UniStrnlen((wchar_t *) ((char *)
1936 &pSMBr->hdr.Protocol +data_offset),
1937 min_t(const int, buflen,count) / 2);
1938 /* BB FIXME investigate remapping reserved chars here */
1939 cifs_strfromUCS_le(symlinkinfo,
1940 (__le16 *) ((char *)&pSMBr->hdr.Protocol +
1942 name_len, nls_codepage);
1944 strncpy(symlinkinfo,
1945 (char *) &pSMBr->hdr.Protocol +
1947 min_t(const int, buflen, count));
1949 symlinkinfo[buflen] = 0;
1950 /* just in case so calling code does not go off the end of buffer */
1953 cifs_buf_release(pSMB);
1955 goto querySymLinkRetry;
1959 /* Initialize NT TRANSACT SMB into small smb request buffer.
1960 This assumes that all NT TRANSACTS that we init here have
1961 total parm and data under about 400 bytes (to fit in small cifs
1962 buffer size), which is the case so far, it easily fits. NB:
1963 Setup words themselves and ByteCount
1964 MaxSetupCount (size of returned setup area) and
1965 MaxParameterCount (returned parms size) must be set by caller */
1967 smb_init_ntransact(const __u16 sub_command, const int setup_count,
1968 const int parm_len, struct cifsTconInfo *tcon,
1973 struct smb_com_ntransact_req * pSMB;
1975 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
1979 *ret_buf = (void *)pSMB;
1981 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
1982 pSMB->TotalDataCount = 0;
1983 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
1984 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
1985 pSMB->ParameterCount = pSMB->TotalParameterCount;
1986 pSMB->DataCount = pSMB->TotalDataCount;
1987 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
1988 (setup_count * 2) - 4 /* for rfc1001 length itself */;
1989 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
1990 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
1991 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
1992 pSMB->SubCommand = cpu_to_le16(sub_command);
1997 validate_ntransact(char * buf, char ** ppparm, char ** ppdata,
1998 int * pdatalen, int * pparmlen)
2001 __u32 data_count, data_offset, parm_count, parm_offset;
2002 struct smb_com_ntransact_rsp * pSMBr;
2007 pSMBr = (struct smb_com_ntransact_rsp *)buf;
2009 /* ByteCount was converted from little endian in SendReceive */
2010 end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2011 (char *)&pSMBr->ByteCount;
2014 data_offset = le32_to_cpu(pSMBr->DataOffset);
2015 data_count = le32_to_cpu(pSMBr->DataCount);
2016 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2017 parm_count = le32_to_cpu(pSMBr->ParameterCount);
2019 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2020 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2022 /* should we also check that parm and data areas do not overlap? */
2023 if(*ppparm > end_of_smb) {
2024 cFYI(1,("parms start after end of smb"));
2026 } else if(parm_count + *ppparm > end_of_smb) {
2027 cFYI(1,("parm end after end of smb"));
2029 } else if(*ppdata > end_of_smb) {
2030 cFYI(1,("data starts after end of smb"));
2032 } else if(data_count + *ppdata > end_of_smb) {
2033 cFYI(1,("data %p + count %d (%p) ends after end of smb %p start %p",
2034 *ppdata, data_count, (data_count + *ppdata), end_of_smb, pSMBr)); /* BB FIXME */
2036 } else if(parm_count + data_count > pSMBr->ByteCount) {
2037 cFYI(1,("parm count and data count larger than SMB"));
2044 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
2045 const unsigned char *searchName,
2046 char *symlinkinfo, const int buflen,__u16 fid,
2047 const struct nls_table *nls_codepage)
2052 struct smb_com_transaction_ioctl_req * pSMB;
2053 struct smb_com_transaction_ioctl_rsp * pSMBr;
2055 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
2056 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2061 pSMB->TotalParameterCount = 0 ;
2062 pSMB->TotalDataCount = 0;
2063 pSMB->MaxParameterCount = cpu_to_le32(2);
2064 /* BB find exact data count max from sess structure BB */
2065 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2066 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2067 pSMB->MaxSetupCount = 4;
2069 pSMB->ParameterOffset = 0;
2070 pSMB->DataCount = 0;
2071 pSMB->DataOffset = 0;
2072 pSMB->SetupCount = 4;
2073 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2074 pSMB->ParameterCount = pSMB->TotalParameterCount;
2075 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2076 pSMB->IsFsctl = 1; /* FSCTL */
2077 pSMB->IsRootFlag = 0;
2078 pSMB->Fid = fid; /* file handle always le */
2079 pSMB->ByteCount = 0;
2081 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2082 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2084 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
2085 } else { /* decode response */
2086 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
2087 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
2088 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
2089 /* BB also check enough total bytes returned */
2090 rc = -EIO; /* bad smb */
2092 if(data_count && (data_count < 2048)) {
2093 char * end_of_smb = 2 /* sizeof byte count */ +
2095 (char *)&pSMBr->ByteCount;
2097 struct reparse_data * reparse_buf = (struct reparse_data *)
2098 ((char *)&pSMBr->hdr.Protocol + data_offset);
2099 if((char*)reparse_buf >= end_of_smb) {
2103 if((reparse_buf->LinkNamesBuf +
2104 reparse_buf->TargetNameOffset +
2105 reparse_buf->TargetNameLen) >
2107 cFYI(1,("reparse buf extended beyond SMB"));
2112 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2113 name_len = UniStrnlen((wchar_t *)
2114 (reparse_buf->LinkNamesBuf +
2115 reparse_buf->TargetNameOffset),
2116 min(buflen/2, reparse_buf->TargetNameLen / 2));
2117 cifs_strfromUCS_le(symlinkinfo,
2118 (__le16 *) (reparse_buf->LinkNamesBuf +
2119 reparse_buf->TargetNameOffset),
2120 name_len, nls_codepage);
2121 } else { /* ASCII names */
2122 strncpy(symlinkinfo,reparse_buf->LinkNamesBuf +
2123 reparse_buf->TargetNameOffset,
2124 min_t(const int, buflen, reparse_buf->TargetNameLen));
2128 cFYI(1,("Invalid return data count on get reparse info ioctl"));
2130 symlinkinfo[buflen] = 0; /* just in case so the caller
2131 does not go off the end of the buffer */
2132 cFYI(1,("readlink result - %s ",symlinkinfo));
2136 cifs_buf_release(pSMB);
2138 /* Note: On -EAGAIN error only caller can retry on handle based calls
2139 since file handle passed in no longer valid */
2144 #ifdef CONFIG_CIFS_POSIX
2146 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
2147 static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace * cifs_ace)
2149 /* u8 cifs fields do not need le conversion */
2150 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
2151 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
2152 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
2153 /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
2158 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
2159 static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
2160 const int acl_type,const int size_of_data_area)
2165 struct cifs_posix_ace * pACE;
2166 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)src;
2167 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)trgt;
2169 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2172 if(acl_type & ACL_TYPE_ACCESS) {
2173 count = le16_to_cpu(cifs_acl->access_entry_count);
2174 pACE = &cifs_acl->ace_array[0];
2175 size = sizeof(struct cifs_posix_acl);
2176 size += sizeof(struct cifs_posix_ace) * count;
2177 /* check if we would go beyond end of SMB */
2178 if(size_of_data_area < size) {
2179 cFYI(1,("bad CIFS POSIX ACL size %d vs. %d",size_of_data_area,size));
2182 } else if(acl_type & ACL_TYPE_DEFAULT) {
2183 count = le16_to_cpu(cifs_acl->access_entry_count);
2184 size = sizeof(struct cifs_posix_acl);
2185 size += sizeof(struct cifs_posix_ace) * count;
2186 /* skip past access ACEs to get to default ACEs */
2187 pACE = &cifs_acl->ace_array[count];
2188 count = le16_to_cpu(cifs_acl->default_entry_count);
2189 size += sizeof(struct cifs_posix_ace) * count;
2190 /* check if we would go beyond end of SMB */
2191 if(size_of_data_area < size)
2198 size = posix_acl_xattr_size(count);
2199 if((buflen == 0) || (local_acl == NULL)) {
2200 /* used to query ACL EA size */
2201 } else if(size > buflen) {
2203 } else /* buffer big enough */ {
2204 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
2205 for(i = 0;i < count ;i++) {
2206 cifs_convert_ace(&local_acl->a_entries[i],pACE);
2213 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace * cifs_ace,
2214 const posix_acl_xattr_entry * local_ace)
2216 __u16 rc = 0; /* 0 = ACL converted ok */
2218 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
2219 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
2220 /* BB is there a better way to handle the large uid? */
2221 if(local_ace->e_id == cpu_to_le32(-1)) {
2222 /* Probably no need to le convert -1 on any arch but can not hurt */
2223 cifs_ace->cifs_uid = cpu_to_le64(-1);
2225 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
2226 /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
2230 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
2231 static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int buflen,
2235 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)parm_data;
2236 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)pACL;
2240 if((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
2243 count = posix_acl_xattr_count((size_t)buflen);
2244 cFYI(1,("setting acl with %d entries from buf of length %d and version of %d",
2245 count, buflen, le32_to_cpu(local_acl->a_version)));
2246 if(le32_to_cpu(local_acl->a_version) != 2) {
2247 cFYI(1,("unknown POSIX ACL version %d",
2248 le32_to_cpu(local_acl->a_version)));
2251 cifs_acl->version = cpu_to_le16(1);
2252 if(acl_type == ACL_TYPE_ACCESS)
2253 cifs_acl->access_entry_count = cpu_to_le16(count);
2254 else if(acl_type == ACL_TYPE_DEFAULT)
2255 cifs_acl->default_entry_count = cpu_to_le16(count);
2257 cFYI(1,("unknown ACL type %d",acl_type));
2260 for(i=0;i<count;i++) {
2261 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
2262 &local_acl->a_entries[i]);
2264 /* ACE not converted */
2269 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
2270 rc += sizeof(struct cifs_posix_acl);
2271 /* BB add check to make sure ACL does not overflow SMB */
2277 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
2278 const unsigned char *searchName,
2279 char *acl_inf, const int buflen, const int acl_type,
2280 const struct nls_table *nls_codepage, int remap)
2282 /* SMB_QUERY_POSIX_ACL */
2283 TRANSACTION2_QPI_REQ *pSMB = NULL;
2284 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2288 __u16 params, byte_count;
2290 cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
2293 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2298 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2300 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2301 PATH_MAX, nls_codepage, remap);
2302 name_len++; /* trailing null */
2304 pSMB->FileName[name_len] = 0;
2305 pSMB->FileName[name_len+1] = 0;
2306 } else { /* BB improve the check for buffer overruns BB */
2307 name_len = strnlen(searchName, PATH_MAX);
2308 name_len++; /* trailing null */
2309 strncpy(pSMB->FileName, searchName, name_len);
2312 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2313 pSMB->TotalDataCount = 0;
2314 pSMB->MaxParameterCount = cpu_to_le16(2);
2315 /* BB find exact max data count below from sess structure BB */
2316 pSMB->MaxDataCount = cpu_to_le16(4000);
2317 pSMB->MaxSetupCount = 0;
2321 pSMB->Reserved2 = 0;
2322 pSMB->ParameterOffset = cpu_to_le16(
2323 offsetof(struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2324 pSMB->DataCount = 0;
2325 pSMB->DataOffset = 0;
2326 pSMB->SetupCount = 1;
2327 pSMB->Reserved3 = 0;
2328 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2329 byte_count = params + 1 /* pad */ ;
2330 pSMB->TotalParameterCount = cpu_to_le16(params);
2331 pSMB->ParameterCount = pSMB->TotalParameterCount;
2332 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
2333 pSMB->Reserved4 = 0;
2334 pSMB->hdr.smb_buf_length += byte_count;
2335 pSMB->ByteCount = cpu_to_le16(byte_count);
2337 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2338 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2339 cifs_stats_inc(&tcon->num_acl_get);
2341 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
2343 /* decode response */
2345 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2346 if (rc || (pSMBr->ByteCount < 2))
2347 /* BB also check enough total bytes returned */
2348 rc = -EIO; /* bad smb */
2350 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2351 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2352 rc = cifs_copy_posix_acl(acl_inf,
2353 (char *)&pSMBr->hdr.Protocol+data_offset,
2354 buflen,acl_type,count);
2357 cifs_buf_release(pSMB);
2364 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2365 const unsigned char *fileName,
2366 const char *local_acl, const int buflen,
2368 const struct nls_table *nls_codepage, int remap)
2370 struct smb_com_transaction2_spi_req *pSMB = NULL;
2371 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2375 int bytes_returned = 0;
2376 __u16 params, byte_count, data_count, param_offset, offset;
2378 cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2380 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2384 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2386 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2387 PATH_MAX, nls_codepage, remap);
2388 name_len++; /* trailing null */
2390 } else { /* BB improve the check for buffer overruns BB */
2391 name_len = strnlen(fileName, PATH_MAX);
2392 name_len++; /* trailing null */
2393 strncpy(pSMB->FileName, fileName, name_len);
2395 params = 6 + name_len;
2396 pSMB->MaxParameterCount = cpu_to_le16(2);
2397 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2398 pSMB->MaxSetupCount = 0;
2402 pSMB->Reserved2 = 0;
2403 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2404 InformationLevel) - 4;
2405 offset = param_offset + params;
2406 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2407 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2409 /* convert to on the wire format for POSIX ACL */
2410 data_count = ACL_to_cifs_posix(parm_data,local_acl,buflen,acl_type);
2412 if(data_count == 0) {
2414 goto setACLerrorExit;
2416 pSMB->DataOffset = cpu_to_le16(offset);
2417 pSMB->SetupCount = 1;
2418 pSMB->Reserved3 = 0;
2419 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2420 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2421 byte_count = 3 /* pad */ + params + data_count;
2422 pSMB->DataCount = cpu_to_le16(data_count);
2423 pSMB->TotalDataCount = pSMB->DataCount;
2424 pSMB->ParameterCount = cpu_to_le16(params);
2425 pSMB->TotalParameterCount = pSMB->ParameterCount;
2426 pSMB->Reserved4 = 0;
2427 pSMB->hdr.smb_buf_length += byte_count;
2428 pSMB->ByteCount = cpu_to_le16(byte_count);
2429 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2430 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2432 cFYI(1, ("Set POSIX ACL returned %d", rc));
2436 cifs_buf_release(pSMB);
2442 /* BB fix tabs in this function FIXME BB */
2444 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2445 const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
2448 struct smb_t2_qfi_req *pSMB = NULL;
2449 struct smb_t2_qfi_rsp *pSMBr = NULL;
2451 __u16 params, byte_count;
2453 cFYI(1,("In GetExtAttr"));
2458 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2463 params = 2 /* level */ +2 /* fid */;
2464 pSMB->t2.TotalDataCount = 0;
2465 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
2466 /* BB find exact max data count below from sess structure BB */
2467 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
2468 pSMB->t2.MaxSetupCount = 0;
2469 pSMB->t2.Reserved = 0;
2471 pSMB->t2.Timeout = 0;
2472 pSMB->t2.Reserved2 = 0;
2473 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
2475 pSMB->t2.DataCount = 0;
2476 pSMB->t2.DataOffset = 0;
2477 pSMB->t2.SetupCount = 1;
2478 pSMB->t2.Reserved3 = 0;
2479 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2480 byte_count = params + 1 /* pad */ ;
2481 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
2482 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
2483 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
2486 pSMB->hdr.smb_buf_length += byte_count;
2487 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
2489 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2490 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2492 cFYI(1, ("error %d in GetExtAttr", rc));
2494 /* decode response */
2495 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2496 if (rc || (pSMBr->ByteCount < 2))
2497 /* BB also check enough total bytes returned */
2498 /* If rc should we check for EOPNOSUPP and
2499 disable the srvino flag? or in caller? */
2500 rc = -EIO; /* bad smb */
2502 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2503 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2504 struct file_chattr_info * pfinfo;
2505 /* BB Do we need a cast or hash here ? */
2507 cFYI(1, ("Illegal size ret in GetExtAttr"));
2511 pfinfo = (struct file_chattr_info *)
2512 (data_offset + (char *) &pSMBr->hdr.Protocol);
2513 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
2514 *pMask = le64_to_cpu(pfinfo->mask);
2518 cifs_buf_release(pSMB);
2520 goto GetExtAttrRetry;
2525 #endif /* CONFIG_POSIX */
2528 /* security id for everyone */
2529 const struct cifs_sid sid_everyone = {1, 1, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0}};
2531 const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {32, 545, 0, 0}};
2533 /* Convert CIFS ACL to POSIX form */
2534 static int parse_sec_desc(struct cifs_sid * psec_desc, int acl_len)
2539 /* Get Security Descriptor (by handle) from remote server for a file or dir */
2541 CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
2542 /* BB fix up return info */ char *acl_inf, const int buflen,
2543 const int acl_type /* ACCESS/DEFAULT not sure implication */)
2547 QUERY_SEC_DESC_REQ * pSMB;
2550 cFYI(1, ("GetCifsACL"));
2552 rc = smb_init_ntransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
2553 8 /* parm len */, tcon, (void **) &pSMB);
2557 pSMB->MaxParameterCount = cpu_to_le32(4);
2558 /* BB TEST with big acls that might need to be e.g. larger than 16K */
2559 pSMB->MaxSetupCount = 0;
2560 pSMB->Fid = fid; /* file handle always le */
2561 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
2563 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
2564 pSMB->hdr.smb_buf_length += 11;
2565 iov[0].iov_base = (char *)pSMB;
2566 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
2568 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type, 0);
2569 cifs_stats_inc(&tcon->num_acl_get);
2571 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
2572 } else { /* decode response */
2573 struct cifs_sid * psec_desc;
2578 struct smb_com_ntransact_rsp * pSMBr;
2580 /* validate_nttransact */
2581 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
2582 (char **)&psec_desc,
2583 &parm_len, &data_len);
2587 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
2589 cERROR(1,("smb %p parm %p data %p",pSMBr,parm,psec_desc)); /* BB removeme BB */
2591 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
2592 rc = -EIO; /* bad smb */
2596 /* BB check that data area is minimum length and as big as acl_len */
2598 acl_len = le32_to_cpu(*(__le32 *)parm);
2599 /* BB check if(acl_len > bufsize) */
2601 parse_sec_desc(psec_desc, acl_len);
2604 if(buf_type == CIFS_SMALL_BUFFER)
2605 cifs_small_buf_release(iov[0].iov_base);
2606 else if(buf_type == CIFS_LARGE_BUFFER)
2607 cifs_buf_release(iov[0].iov_base);
2608 cifs_small_buf_release(pSMB);
2613 /* Legacy Query Path Information call for lookup to old servers such
2615 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
2616 const unsigned char *searchName,
2617 FILE_ALL_INFO * pFinfo,
2618 const struct nls_table *nls_codepage, int remap)
2620 QUERY_INFORMATION_REQ * pSMB;
2621 QUERY_INFORMATION_RSP * pSMBr;
2626 cFYI(1, ("In SMBQPath path %s", searchName));
2628 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
2633 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2635 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2636 PATH_MAX, nls_codepage, remap);
2637 name_len++; /* trailing null */
2640 name_len = strnlen(searchName, PATH_MAX);
2641 name_len++; /* trailing null */
2642 strncpy(pSMB->FileName, searchName, name_len);
2644 pSMB->BufferFormat = 0x04;
2645 name_len++; /* account for buffer type byte */
2646 pSMB->hdr.smb_buf_length += (__u16) name_len;
2647 pSMB->ByteCount = cpu_to_le16(name_len);
2649 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2650 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2652 cFYI(1, ("Send error in QueryInfo = %d", rc));
2653 } else if (pFinfo) { /* decode response */
2654 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
2655 pFinfo->AllocationSize =
2656 cpu_to_le64(le32_to_cpu(pSMBr->size));
2657 pFinfo->EndOfFile = pFinfo->AllocationSize;
2658 pFinfo->Attributes =
2659 cpu_to_le32(le16_to_cpu(pSMBr->attr));
2661 rc = -EIO; /* bad buffer passed in */
2663 cifs_buf_release(pSMB);
2675 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
2676 const unsigned char *searchName,
2677 FILE_ALL_INFO * pFindData,
2678 const struct nls_table *nls_codepage, int remap)
2680 /* level 263 SMB_QUERY_FILE_ALL_INFO */
2681 TRANSACTION2_QPI_REQ *pSMB = NULL;
2682 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2686 __u16 params, byte_count;
2688 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
2690 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2695 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2697 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2698 PATH_MAX, nls_codepage, remap);
2699 name_len++; /* trailing null */
2701 } else { /* BB improve the check for buffer overruns BB */
2702 name_len = strnlen(searchName, PATH_MAX);
2703 name_len++; /* trailing null */
2704 strncpy(pSMB->FileName, searchName, name_len);
2707 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2708 pSMB->TotalDataCount = 0;
2709 pSMB->MaxParameterCount = cpu_to_le16(2);
2710 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2711 pSMB->MaxSetupCount = 0;
2715 pSMB->Reserved2 = 0;
2716 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2717 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2718 pSMB->DataCount = 0;
2719 pSMB->DataOffset = 0;
2720 pSMB->SetupCount = 1;
2721 pSMB->Reserved3 = 0;
2722 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2723 byte_count = params + 1 /* pad */ ;
2724 pSMB->TotalParameterCount = cpu_to_le16(params);
2725 pSMB->ParameterCount = pSMB->TotalParameterCount;
2726 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
2727 pSMB->Reserved4 = 0;
2728 pSMB->hdr.smb_buf_length += byte_count;
2729 pSMB->ByteCount = cpu_to_le16(byte_count);
2731 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2732 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2734 cFYI(1, ("Send error in QPathInfo = %d", rc));
2735 } else { /* decode response */
2736 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2738 if (rc || (pSMBr->ByteCount < 40))
2739 rc = -EIO; /* bad smb */
2740 else if (pFindData){
2741 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2742 memcpy((char *) pFindData,
2743 (char *) &pSMBr->hdr.Protocol +
2744 data_offset, sizeof (FILE_ALL_INFO));
2748 cifs_buf_release(pSMB);
2750 goto QPathInfoRetry;
2756 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
2757 const unsigned char *searchName,
2758 FILE_UNIX_BASIC_INFO * pFindData,
2759 const struct nls_table *nls_codepage, int remap)
2761 /* SMB_QUERY_FILE_UNIX_BASIC */
2762 TRANSACTION2_QPI_REQ *pSMB = NULL;
2763 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2765 int bytes_returned = 0;
2767 __u16 params, byte_count;
2769 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
2771 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2776 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2778 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2779 PATH_MAX, nls_codepage, remap);
2780 name_len++; /* trailing null */
2782 } else { /* BB improve the check for buffer overruns BB */
2783 name_len = strnlen(searchName, PATH_MAX);
2784 name_len++; /* trailing null */
2785 strncpy(pSMB->FileName, searchName, name_len);
2788 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2789 pSMB->TotalDataCount = 0;
2790 pSMB->MaxParameterCount = cpu_to_le16(2);
2791 /* BB find exact max SMB PDU from sess structure BB */
2792 pSMB->MaxDataCount = cpu_to_le16(4000);
2793 pSMB->MaxSetupCount = 0;
2797 pSMB->Reserved2 = 0;
2798 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2799 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2800 pSMB->DataCount = 0;
2801 pSMB->DataOffset = 0;
2802 pSMB->SetupCount = 1;
2803 pSMB->Reserved3 = 0;
2804 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2805 byte_count = params + 1 /* pad */ ;
2806 pSMB->TotalParameterCount = cpu_to_le16(params);
2807 pSMB->ParameterCount = pSMB->TotalParameterCount;
2808 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
2809 pSMB->Reserved4 = 0;
2810 pSMB->hdr.smb_buf_length += byte_count;
2811 pSMB->ByteCount = cpu_to_le16(byte_count);
2813 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2814 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2816 cFYI(1, ("Send error in QPathInfo = %d", rc));
2817 } else { /* decode response */
2818 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2820 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
2821 rc = -EIO; /* bad smb */
2823 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2824 memcpy((char *) pFindData,
2825 (char *) &pSMBr->hdr.Protocol +
2827 sizeof (FILE_UNIX_BASIC_INFO));
2830 cifs_buf_release(pSMB);
2832 goto UnixQPathInfoRetry;
2837 #if 0 /* function unused at present */
2838 int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
2839 const char *searchName, FILE_ALL_INFO * findData,
2840 const struct nls_table *nls_codepage)
2842 /* level 257 SMB_ */
2843 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2844 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2848 __u16 params, byte_count;
2850 cFYI(1, ("In FindUnique"));
2852 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2857 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2859 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
2860 /* find define for this maxpathcomponent */
2862 name_len++; /* trailing null */
2864 } else { /* BB improve the check for buffer overruns BB */
2865 name_len = strnlen(searchName, PATH_MAX);
2866 name_len++; /* trailing null */
2867 strncpy(pSMB->FileName, searchName, name_len);
2870 params = 12 + name_len /* includes null */ ;
2871 pSMB->TotalDataCount = 0; /* no EAs */
2872 pSMB->MaxParameterCount = cpu_to_le16(2);
2873 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2874 pSMB->MaxSetupCount = 0;
2878 pSMB->Reserved2 = 0;
2879 pSMB->ParameterOffset = cpu_to_le16(
2880 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
2881 pSMB->DataCount = 0;
2882 pSMB->DataOffset = 0;
2883 pSMB->SetupCount = 1; /* one byte, no need to le convert */
2884 pSMB->Reserved3 = 0;
2885 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2886 byte_count = params + 1 /* pad */ ;
2887 pSMB->TotalParameterCount = cpu_to_le16(params);
2888 pSMB->ParameterCount = pSMB->TotalParameterCount;
2889 pSMB->SearchAttributes =
2890 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2892 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
2893 pSMB->SearchFlags = cpu_to_le16(1);
2894 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2895 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
2896 pSMB->hdr.smb_buf_length += byte_count;
2897 pSMB->ByteCount = cpu_to_le16(byte_count);
2899 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2900 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2903 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
2904 } else { /* decode response */
2905 cifs_stats_inc(&tcon->num_ffirst);
2909 cifs_buf_release(pSMB);
2911 goto findUniqueRetry;
2915 #endif /* end unused (temporarily) function */
2917 /* xid, tcon, searchName and codepage are input parms, rest are returned */
2919 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
2920 const char *searchName,
2921 const struct nls_table *nls_codepage,
2923 struct cifs_search_info * psrch_inf, int remap, const char dirsep)
2925 /* level 257 SMB_ */
2926 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2927 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2928 T2_FFIRST_RSP_PARMS * parms;
2930 int bytes_returned = 0;
2932 __u16 params, byte_count;
2934 cFYI(1, ("In FindFirst for %s",searchName));
2937 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2942 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2944 cifsConvertToUCS((__le16 *) pSMB->FileName,searchName,
2945 PATH_MAX, nls_codepage, remap);
2946 /* We can not add the asterik earlier in case
2947 it got remapped to 0xF03A as if it were part of the
2948 directory name instead of a wildcard */
2950 pSMB->FileName[name_len] = dirsep;
2951 pSMB->FileName[name_len+1] = 0;
2952 pSMB->FileName[name_len+2] = '*';
2953 pSMB->FileName[name_len+3] = 0;
2954 name_len += 4; /* now the trailing null */
2955 pSMB->FileName[name_len] = 0; /* null terminate just in case */
2956 pSMB->FileName[name_len+1] = 0;
2958 } else { /* BB add check for overrun of SMB buf BB */
2959 name_len = strnlen(searchName, PATH_MAX);
2960 /* BB fix here and in unicode clause above ie
2961 if(name_len > buffersize-header)
2962 free buffer exit; BB */
2963 strncpy(pSMB->FileName, searchName, name_len);
2964 pSMB->FileName[name_len] = dirsep;
2965 pSMB->FileName[name_len+1] = '*';
2966 pSMB->FileName[name_len+2] = 0;
2970 params = 12 + name_len /* includes null */ ;
2971 pSMB->TotalDataCount = 0; /* no EAs */
2972 pSMB->MaxParameterCount = cpu_to_le16(10);
2973 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
2974 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2975 pSMB->MaxSetupCount = 0;
2979 pSMB->Reserved2 = 0;
2980 byte_count = params + 1 /* pad */ ;
2981 pSMB->TotalParameterCount = cpu_to_le16(params);
2982 pSMB->ParameterCount = pSMB->TotalParameterCount;
2983 pSMB->ParameterOffset = cpu_to_le16(
2984 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
2985 pSMB->DataCount = 0;
2986 pSMB->DataOffset = 0;
2987 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
2988 pSMB->Reserved3 = 0;
2989 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2990 pSMB->SearchAttributes =
2991 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2993 pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
2994 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
2995 CIFS_SEARCH_RETURN_RESUME);
2996 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2998 /* BB what should we set StorageType to? Does it matter? BB */
2999 pSMB->SearchStorageType = 0;
3000 pSMB->hdr.smb_buf_length += byte_count;
3001 pSMB->ByteCount = cpu_to_le16(byte_count);
3003 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3004 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3005 cifs_stats_inc(&tcon->num_ffirst);
3007 if (rc) {/* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
3008 /* BB Add code to handle unsupported level rc */
3009 cFYI(1, ("Error in FindFirst = %d", rc));
3012 cifs_buf_release(pSMB);
3014 /* BB eventually could optimize out free and realloc of buf */
3017 goto findFirstRetry;
3018 } else { /* decode response */
3019 /* BB remember to free buffer if error BB */
3020 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3022 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3023 psrch_inf->unicode = TRUE;
3025 psrch_inf->unicode = FALSE;
3027 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3028 psrch_inf->srch_entries_start =
3029 (char *) &pSMBr->hdr.Protocol +
3030 le16_to_cpu(pSMBr->t2.DataOffset);
3031 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3032 le16_to_cpu(pSMBr->t2.ParameterOffset));
3034 if(parms->EndofSearch)
3035 psrch_inf->endOfSearch = TRUE;
3037 psrch_inf->endOfSearch = FALSE;
3039 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
3040 psrch_inf->index_of_last_entry =
3041 psrch_inf->entries_in_buffer;
3042 *pnetfid = parms->SearchHandle;
3044 cifs_buf_release(pSMB);
3051 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3052 __u16 searchHandle, struct cifs_search_info * psrch_inf)
3054 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3055 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3056 T2_FNEXT_RSP_PARMS * parms;
3057 char *response_data;
3059 int bytes_returned, name_len;
3060 __u16 params, byte_count;
3062 cFYI(1, ("In FindNext"));
3064 if(psrch_inf->endOfSearch == TRUE)
3067 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3072 params = 14; /* includes 2 bytes of null string, converted to LE below */
3074 pSMB->TotalDataCount = 0; /* no EAs */
3075 pSMB->MaxParameterCount = cpu_to_le16(8);
3076 pSMB->MaxDataCount =
3077 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3078 pSMB->MaxSetupCount = 0;
3082 pSMB->Reserved2 = 0;
3083 pSMB->ParameterOffset = cpu_to_le16(
3084 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3085 pSMB->DataCount = 0;
3086 pSMB->DataOffset = 0;
3087 pSMB->SetupCount = 1;
3088 pSMB->Reserved3 = 0;
3089 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3090 pSMB->SearchHandle = searchHandle; /* always kept as le */
3092 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
3093 /* test for Unix extensions */
3094 /* if (tcon->ses->capabilities & CAP_UNIX) {
3095 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
3096 psrch_inf->info_level = SMB_FIND_FILE_UNIX;
3098 pSMB->InformationLevel =
3099 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
3100 psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
3102 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3103 pSMB->ResumeKey = psrch_inf->resume_key;
3105 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3107 name_len = psrch_inf->resume_name_len;
3109 if(name_len < PATH_MAX) {
3110 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3111 byte_count += name_len;
3112 /* 14 byte parm len above enough for 2 byte null terminator */
3113 pSMB->ResumeFileName[name_len] = 0;
3114 pSMB->ResumeFileName[name_len+1] = 0;
3117 goto FNext2_err_exit;
3119 byte_count = params + 1 /* pad */ ;
3120 pSMB->TotalParameterCount = cpu_to_le16(params);
3121 pSMB->ParameterCount = pSMB->TotalParameterCount;
3122 pSMB->hdr.smb_buf_length += byte_count;
3123 pSMB->ByteCount = cpu_to_le16(byte_count);
3125 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3126 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3127 cifs_stats_inc(&tcon->num_fnext);
3130 psrch_inf->endOfSearch = TRUE;
3131 rc = 0; /* search probably was closed at end of search above */
3133 cFYI(1, ("FindNext returned = %d", rc));
3134 } else { /* decode response */
3135 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3138 /* BB fixme add lock for file (srch_info) struct here */
3139 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3140 psrch_inf->unicode = TRUE;
3142 psrch_inf->unicode = FALSE;
3143 response_data = (char *) &pSMBr->hdr.Protocol +
3144 le16_to_cpu(pSMBr->t2.ParameterOffset);
3145 parms = (T2_FNEXT_RSP_PARMS *)response_data;
3146 response_data = (char *)&pSMBr->hdr.Protocol +
3147 le16_to_cpu(pSMBr->t2.DataOffset);
3148 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3149 psrch_inf->srch_entries_start = response_data;
3150 psrch_inf->ntwrk_buf_start = (char *)pSMB;
3151 if(parms->EndofSearch)
3152 psrch_inf->endOfSearch = TRUE;
3154 psrch_inf->endOfSearch = FALSE;
3156 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
3157 psrch_inf->index_of_last_entry +=
3158 psrch_inf->entries_in_buffer;
3159 /* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
3161 /* BB fixme add unlock here */
3166 /* BB On error, should we leave previous search buf (and count and
3167 last entry fields) intact or free the previous one? */
3169 /* Note: On -EAGAIN error only caller can retry on handle based calls
3170 since file handle passed in no longer valid */
3173 cifs_buf_release(pSMB);
3179 CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
3182 FINDCLOSE_REQ *pSMB = NULL;
3183 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
3186 cFYI(1, ("In CIFSSMBFindClose"));
3187 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3189 /* no sense returning error if session restarted
3190 as file handle has been closed */
3196 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
3197 pSMB->FileID = searchHandle;
3198 pSMB->ByteCount = 0;
3199 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3200 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3202 cERROR(1, ("Send error in FindClose = %d", rc));
3204 cifs_stats_inc(&tcon->num_fclose);
3205 cifs_small_buf_release(pSMB);
3207 /* Since session is dead, search handle closed on server already */
3215 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3216 const unsigned char *searchName,
3217 __u64 * inode_number,
3218 const struct nls_table *nls_codepage, int remap)
3221 TRANSACTION2_QPI_REQ *pSMB = NULL;
3222 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3223 int name_len, bytes_returned;
3224 __u16 params, byte_count;
3226 cFYI(1,("In GetSrvInodeNum for %s",searchName));
3230 GetInodeNumberRetry:
3231 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3237 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3239 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3240 PATH_MAX,nls_codepage, remap);
3241 name_len++; /* trailing null */
3243 } else { /* BB improve the check for buffer overruns BB */
3244 name_len = strnlen(searchName, PATH_MAX);
3245 name_len++; /* trailing null */
3246 strncpy(pSMB->FileName, searchName, name_len);
3249 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3250 pSMB->TotalDataCount = 0;
3251 pSMB->MaxParameterCount = cpu_to_le16(2);
3252 /* BB find exact max data count below from sess structure BB */
3253 pSMB->MaxDataCount = cpu_to_le16(4000);
3254 pSMB->MaxSetupCount = 0;
3258 pSMB->Reserved2 = 0;
3259 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3260 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3261 pSMB->DataCount = 0;
3262 pSMB->DataOffset = 0;
3263 pSMB->SetupCount = 1;
3264 pSMB->Reserved3 = 0;
3265 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3266 byte_count = params + 1 /* pad */ ;
3267 pSMB->TotalParameterCount = cpu_to_le16(params);
3268 pSMB->ParameterCount = pSMB->TotalParameterCount;
3269 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3270 pSMB->Reserved4 = 0;
3271 pSMB->hdr.smb_buf_length += byte_count;
3272 pSMB->ByteCount = cpu_to_le16(byte_count);
3274 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3275 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3277 cFYI(1, ("error %d in QueryInternalInfo", rc));
3279 /* decode response */
3280 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3281 if (rc || (pSMBr->ByteCount < 2))
3282 /* BB also check enough total bytes returned */
3283 /* If rc should we check for EOPNOSUPP and
3284 disable the srvino flag? or in caller? */
3285 rc = -EIO; /* bad smb */
3287 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3288 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3289 struct file_internal_info * pfinfo;
3290 /* BB Do we need a cast or hash here ? */
3292 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3294 goto GetInodeNumOut;
3296 pfinfo = (struct file_internal_info *)
3297 (data_offset + (char *) &pSMBr->hdr.Protocol);
3298 *inode_number = pfinfo->UniqueId;
3302 cifs_buf_release(pSMB);
3304 goto GetInodeNumberRetry;
3309 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3310 const unsigned char *searchName,
3311 unsigned char **targetUNCs,
3312 unsigned int *number_of_UNC_in_array,
3313 const struct nls_table *nls_codepage, int remap)
3315 /* TRANS2_GET_DFS_REFERRAL */
3316 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
3317 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
3318 struct dfs_referral_level_3 * referrals = NULL;
3324 __u16 params, byte_count;
3325 *number_of_UNC_in_array = 0;
3328 cFYI(1, ("In GetDFSRefer the path %s", searchName));
3332 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
3337 /* server pointer checked in called function,
3338 but should never be null here anyway */
3339 pSMB->hdr.Mid = GetNextMid(ses->server);
3340 pSMB->hdr.Tid = ses->ipc_tid;
3341 pSMB->hdr.Uid = ses->Suid;
3342 if (ses->capabilities & CAP_STATUS32) {
3343 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
3345 if (ses->capabilities & CAP_DFS) {
3346 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
3349 if (ses->capabilities & CAP_UNICODE) {
3350 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
3352 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
3353 searchName, PATH_MAX, nls_codepage, remap);
3354 name_len++; /* trailing null */
3356 } else { /* BB improve the check for buffer overruns BB */
3357 name_len = strnlen(searchName, PATH_MAX);
3358 name_len++; /* trailing null */
3359 strncpy(pSMB->RequestFileName, searchName, name_len);
3362 params = 2 /* level */ + name_len /*includes null */ ;
3363 pSMB->TotalDataCount = 0;
3364 pSMB->DataCount = 0;
3365 pSMB->DataOffset = 0;
3366 pSMB->MaxParameterCount = 0;
3367 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3368 pSMB->MaxSetupCount = 0;
3372 pSMB->Reserved2 = 0;
3373 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3374 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
3375 pSMB->SetupCount = 1;
3376 pSMB->Reserved3 = 0;
3377 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
3378 byte_count = params + 3 /* pad */ ;
3379 pSMB->ParameterCount = cpu_to_le16(params);
3380 pSMB->TotalParameterCount = pSMB->ParameterCount;
3381 pSMB->MaxReferralLevel = cpu_to_le16(3);
3382 pSMB->hdr.smb_buf_length += byte_count;
3383 pSMB->ByteCount = cpu_to_le16(byte_count);
3385 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
3386 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3388 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
3389 } else { /* decode response */
3390 /* BB Add logic to parse referrals here */
3391 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3393 if (rc || (pSMBr->ByteCount < 17)) /* BB also check enough total bytes returned */
3394 rc = -EIO; /* bad smb */
3396 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3397 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
3400 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
3401 pSMBr->ByteCount, data_offset));
3403 (struct dfs_referral_level_3 *)
3404 (8 /* sizeof start of data block */ +
3406 (char *) &pSMBr->hdr.Protocol);
3407 cFYI(1,("num_referrals: %d dfs flags: 0x%x ... \nfor referral one refer size: 0x%x srv type: 0x%x refer flags: 0x%x ttl: 0x%x",
3408 le16_to_cpu(pSMBr->NumberOfReferrals),le16_to_cpu(pSMBr->DFSFlags), le16_to_cpu(referrals->ReferralSize),le16_to_cpu(referrals->ServerType),le16_to_cpu(referrals->ReferralFlags),le16_to_cpu(referrals->TimeToLive)));
3409 /* BB This field is actually two bytes in from start of
3410 data block so we could do safety check that DataBlock
3411 begins at address of pSMBr->NumberOfReferrals */
3412 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
3414 /* BB Fix below so can return more than one referral */
3415 if(*number_of_UNC_in_array > 1)
3416 *number_of_UNC_in_array = 1;
3418 /* get the length of the strings describing refs */
3420 for(i=0;i<*number_of_UNC_in_array;i++) {
3421 /* make sure that DfsPathOffset not past end */
3422 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
3423 if (offset > data_count) {
3424 /* if invalid referral, stop here and do
3425 not try to copy any more */
3426 *number_of_UNC_in_array = i;
3429 temp = ((char *)referrals) + offset;
3431 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3432 name_len += UniStrnlen((wchar_t *)temp,data_count);
3434 name_len += strnlen(temp,data_count);
3437 /* BB add check that referral pointer does not fall off end PDU */
3440 /* BB add check for name_len bigger than bcc */
3442 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
3443 if(*targetUNCs == NULL) {
3447 /* copy the ref strings */
3449 (struct dfs_referral_level_3 *)
3450 (8 /* sizeof data hdr */ +
3452 (char *) &pSMBr->hdr.Protocol);
3454 for(i=0;i<*number_of_UNC_in_array;i++) {
3455 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
3456 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3457 cifs_strfromUCS_le(*targetUNCs,
3458 (__le16 *) temp, name_len, nls_codepage);
3460 strncpy(*targetUNCs,temp,name_len);
3462 /* BB update target_uncs pointers */
3472 cifs_buf_release(pSMB);
3480 /* Query File System Info such as free space to old servers such as Win 9x */
3482 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
3484 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
3485 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3486 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3487 FILE_SYSTEM_ALLOC_INFO *response_data;
3489 int bytes_returned = 0;
3490 __u16 params, byte_count;
3492 cFYI(1, ("OldQFSInfo"));
3494 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3498 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3503 params = 2; /* level */
3504 pSMB->TotalDataCount = 0;
3505 pSMB->MaxParameterCount = cpu_to_le16(2);
3506 pSMB->MaxDataCount = cpu_to_le16(1000);
3507 pSMB->MaxSetupCount = 0;
3511 pSMB->Reserved2 = 0;
3512 byte_count = params + 1 /* pad */ ;
3513 pSMB->TotalParameterCount = cpu_to_le16(params);
3514 pSMB->ParameterCount = pSMB->TotalParameterCount;
3515 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3516 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3517 pSMB->DataCount = 0;
3518 pSMB->DataOffset = 0;
3519 pSMB->SetupCount = 1;
3520 pSMB->Reserved3 = 0;
3521 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3522 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
3523 pSMB->hdr.smb_buf_length += byte_count;
3524 pSMB->ByteCount = cpu_to_le16(byte_count);
3526 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3527 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3529 cFYI(1, ("Send error in QFSInfo = %d", rc));
3530 } else { /* decode response */
3531 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3533 if (rc || (pSMBr->ByteCount < 18))
3534 rc = -EIO; /* bad smb */
3536 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3537 cFYI(1,("qfsinf resp BCC: %d Offset %d",
3538 pSMBr->ByteCount, data_offset));
3541 (FILE_SYSTEM_ALLOC_INFO *)
3542 (((char *) &pSMBr->hdr.Protocol) + data_offset);
3544 le16_to_cpu(response_data->BytesPerSector) *
3545 le32_to_cpu(response_data->
3546 SectorsPerAllocationUnit);
3548 le32_to_cpu(response_data->TotalAllocationUnits);
3549 FSData->f_bfree = FSData->f_bavail =
3550 le32_to_cpu(response_data->FreeAllocationUnits);
3552 ("Blocks: %lld Free: %lld Block size %ld",
3553 (unsigned long long)FSData->f_blocks,
3554 (unsigned long long)FSData->f_bfree,
3558 cifs_buf_release(pSMB);
3561 goto oldQFSInfoRetry;
3567 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
3569 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
3570 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3571 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3572 FILE_SYSTEM_INFO *response_data;
3574 int bytes_returned = 0;
3575 __u16 params, byte_count;
3577 cFYI(1, ("In QFSInfo"));
3579 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3584 params = 2; /* level */
3585 pSMB->TotalDataCount = 0;
3586 pSMB->MaxParameterCount = cpu_to_le16(2);
3587 pSMB->MaxDataCount = cpu_to_le16(1000);
3588 pSMB->MaxSetupCount = 0;
3592 pSMB->Reserved2 = 0;
3593 byte_count = params + 1 /* pad */ ;
3594 pSMB->TotalParameterCount = cpu_to_le16(params);
3595 pSMB->ParameterCount = pSMB->TotalParameterCount;
3596 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3597 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3598 pSMB->DataCount = 0;
3599 pSMB->DataOffset = 0;
3600 pSMB->SetupCount = 1;
3601 pSMB->Reserved3 = 0;
3602 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3603 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
3604 pSMB->hdr.smb_buf_length += byte_count;
3605 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, ("Send error in QFSInfo = %d", rc));
3611 } else { /* decode response */
3612 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3614 if (rc || (pSMBr->ByteCount < 24))
3615 rc = -EIO; /* bad smb */
3617 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3621 *) (((char *) &pSMBr->hdr.Protocol) +
3624 le32_to_cpu(response_data->BytesPerSector) *
3625 le32_to_cpu(response_data->
3626 SectorsPerAllocationUnit);
3628 le64_to_cpu(response_data->TotalAllocationUnits);
3629 FSData->f_bfree = FSData->f_bavail =
3630 le64_to_cpu(response_data->FreeAllocationUnits);
3632 ("Blocks: %lld Free: %lld Block size %ld",
3633 (unsigned long long)FSData->f_blocks,
3634 (unsigned long long)FSData->f_bfree,
3638 cifs_buf_release(pSMB);
3647 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
3649 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
3650 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3651 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3652 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
3654 int bytes_returned = 0;
3655 __u16 params, byte_count;
3657 cFYI(1, ("In QFSAttributeInfo"));
3659 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3664 params = 2; /* level */
3665 pSMB->TotalDataCount = 0;
3666 pSMB->MaxParameterCount = cpu_to_le16(2);
3667 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3668 pSMB->MaxSetupCount = 0;
3672 pSMB->Reserved2 = 0;
3673 byte_count = params + 1 /* pad */ ;
3674 pSMB->TotalParameterCount = cpu_to_le16(params);
3675 pSMB->ParameterCount = pSMB->TotalParameterCount;
3676 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3677 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3678 pSMB->DataCount = 0;
3679 pSMB->DataOffset = 0;
3680 pSMB->SetupCount = 1;
3681 pSMB->Reserved3 = 0;
3682 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3683 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
3684 pSMB->hdr.smb_buf_length += byte_count;
3685 pSMB->ByteCount = cpu_to_le16(byte_count);
3687 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3688 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3690 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
3691 } else { /* decode response */
3692 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3694 if (rc || (pSMBr->ByteCount < 13)) { /* BB also check enough bytes returned */
3695 rc = -EIO; /* bad smb */
3697 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3699 (FILE_SYSTEM_ATTRIBUTE_INFO
3700 *) (((char *) &pSMBr->hdr.Protocol) +
3702 memcpy(&tcon->fsAttrInfo, response_data,
3703 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
3706 cifs_buf_release(pSMB);
3709 goto QFSAttributeRetry;
3715 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
3717 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
3718 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3719 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3720 FILE_SYSTEM_DEVICE_INFO *response_data;
3722 int bytes_returned = 0;
3723 __u16 params, byte_count;
3725 cFYI(1, ("In QFSDeviceInfo"));
3727 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3732 params = 2; /* level */
3733 pSMB->TotalDataCount = 0;
3734 pSMB->MaxParameterCount = cpu_to_le16(2);
3735 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3736 pSMB->MaxSetupCount = 0;
3740 pSMB->Reserved2 = 0;
3741 byte_count = params + 1 /* pad */ ;
3742 pSMB->TotalParameterCount = cpu_to_le16(params);
3743 pSMB->ParameterCount = pSMB->TotalParameterCount;
3744 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3745 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3747 pSMB->DataCount = 0;
3748 pSMB->DataOffset = 0;
3749 pSMB->SetupCount = 1;
3750 pSMB->Reserved3 = 0;
3751 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3752 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
3753 pSMB->hdr.smb_buf_length += byte_count;
3754 pSMB->ByteCount = cpu_to_le16(byte_count);
3756 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3757 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3759 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
3760 } else { /* decode response */
3761 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3763 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
3764 rc = -EIO; /* bad smb */
3766 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3768 (FILE_SYSTEM_DEVICE_INFO *)
3769 (((char *) &pSMBr->hdr.Protocol) +
3771 memcpy(&tcon->fsDevInfo, response_data,
3772 sizeof (FILE_SYSTEM_DEVICE_INFO));
3775 cifs_buf_release(pSMB);
3778 goto QFSDeviceRetry;
3784 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
3786 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
3787 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3788 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3789 FILE_SYSTEM_UNIX_INFO *response_data;
3791 int bytes_returned = 0;
3792 __u16 params, byte_count;
3794 cFYI(1, ("In QFSUnixInfo"));
3796 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3801 params = 2; /* level */
3802 pSMB->TotalDataCount = 0;
3803 pSMB->DataCount = 0;
3804 pSMB->DataOffset = 0;
3805 pSMB->MaxParameterCount = cpu_to_le16(2);
3806 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3807 pSMB->MaxSetupCount = 0;
3811 pSMB->Reserved2 = 0;
3812 byte_count = params + 1 /* pad */ ;
3813 pSMB->ParameterCount = cpu_to_le16(params);
3814 pSMB->TotalParameterCount = pSMB->ParameterCount;
3815 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3816 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3817 pSMB->SetupCount = 1;
3818 pSMB->Reserved3 = 0;
3819 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3820 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
3821 pSMB->hdr.smb_buf_length += byte_count;
3822 pSMB->ByteCount = cpu_to_le16(byte_count);
3824 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3825 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3827 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
3828 } else { /* decode response */
3829 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3831 if (rc || (pSMBr->ByteCount < 13)) {
3832 rc = -EIO; /* bad smb */
3834 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3836 (FILE_SYSTEM_UNIX_INFO
3837 *) (((char *) &pSMBr->hdr.Protocol) +
3839 memcpy(&tcon->fsUnixInfo, response_data,
3840 sizeof (FILE_SYSTEM_UNIX_INFO));
3843 cifs_buf_release(pSMB);
3853 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
3855 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
3856 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
3857 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
3859 int bytes_returned = 0;
3860 __u16 params, param_offset, offset, byte_count;
3862 cFYI(1, ("In SETFSUnixInfo"));
3864 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3869 params = 4; /* 2 bytes zero followed by info level. */
3870 pSMB->MaxSetupCount = 0;
3874 pSMB->Reserved2 = 0;
3875 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum) - 4;
3876 offset = param_offset + params;
3878 pSMB->MaxParameterCount = cpu_to_le16(4);
3879 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3880 pSMB->SetupCount = 1;
3881 pSMB->Reserved3 = 0;
3882 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
3883 byte_count = 1 /* pad */ + params + 12;
3885 pSMB->DataCount = cpu_to_le16(12);
3886 pSMB->ParameterCount = cpu_to_le16(params);
3887 pSMB->TotalDataCount = pSMB->DataCount;
3888 pSMB->TotalParameterCount = pSMB->ParameterCount;
3889 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3890 pSMB->DataOffset = cpu_to_le16(offset);
3894 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
3897 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
3898 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
3899 pSMB->ClientUnixCap = cpu_to_le64(cap);
3901 pSMB->hdr.smb_buf_length += byte_count;
3902 pSMB->ByteCount = cpu_to_le16(byte_count);
3904 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3905 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3907 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
3908 } else { /* decode response */
3909 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3911 rc = -EIO; /* bad smb */
3914 cifs_buf_release(pSMB);
3917 goto SETFSUnixRetry;
3925 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
3926 struct kstatfs *FSData)
3928 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
3929 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3930 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3931 FILE_SYSTEM_POSIX_INFO *response_data;
3933 int bytes_returned = 0;
3934 __u16 params, byte_count;
3936 cFYI(1, ("In QFSPosixInfo"));
3938 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3943 params = 2; /* level */
3944 pSMB->TotalDataCount = 0;
3945 pSMB->DataCount = 0;
3946 pSMB->DataOffset = 0;
3947 pSMB->MaxParameterCount = cpu_to_le16(2);
3948 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3949 pSMB->MaxSetupCount = 0;
3953 pSMB->Reserved2 = 0;
3954 byte_count = params + 1 /* pad */ ;
3955 pSMB->ParameterCount = cpu_to_le16(params);
3956 pSMB->TotalParameterCount = pSMB->ParameterCount;
3957 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3958 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3959 pSMB->SetupCount = 1;
3960 pSMB->Reserved3 = 0;
3961 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3962 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
3963 pSMB->hdr.smb_buf_length += byte_count;
3964 pSMB->ByteCount = cpu_to_le16(byte_count);
3966 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3967 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3969 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
3970 } else { /* decode response */
3971 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3973 if (rc || (pSMBr->ByteCount < 13)) {
3974 rc = -EIO; /* bad smb */
3976 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3978 (FILE_SYSTEM_POSIX_INFO
3979 *) (((char *) &pSMBr->hdr.Protocol) +
3982 le32_to_cpu(response_data->BlockSize);
3984 le64_to_cpu(response_data->TotalBlocks);
3986 le64_to_cpu(response_data->BlocksAvail);
3987 if(response_data->UserBlocksAvail == cpu_to_le64(-1)) {
3988 FSData->f_bavail = FSData->f_bfree;
3991 le64_to_cpu(response_data->UserBlocksAvail);
3993 if(response_data->TotalFileNodes != cpu_to_le64(-1))
3995 le64_to_cpu(response_data->TotalFileNodes);
3996 if(response_data->FreeFileNodes != cpu_to_le64(-1))
3998 le64_to_cpu(response_data->FreeFileNodes);
4001 cifs_buf_release(pSMB);
4010 /* We can not use write of zero bytes trick to
4011 set file size due to need for large file support. Also note that
4012 this SetPathInfo is preferred to SetFileInfo based method in next
4013 routine which is only needed to work around a sharing violation bug
4014 in Samba which this routine can run into */
4017 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4018 __u64 size, int SetAllocation,
4019 const struct nls_table *nls_codepage, int remap)
4021 struct smb_com_transaction2_spi_req *pSMB = NULL;
4022 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4023 struct file_end_of_file_info *parm_data;
4026 int bytes_returned = 0;
4027 __u16 params, byte_count, data_count, param_offset, offset;
4029 cFYI(1, ("In SetEOF"));
4031 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4036 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4038 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4039 PATH_MAX, nls_codepage, remap);
4040 name_len++; /* trailing null */
4042 } else { /* BB improve the check for buffer overruns BB */
4043 name_len = strnlen(fileName, PATH_MAX);
4044 name_len++; /* trailing null */
4045 strncpy(pSMB->FileName, fileName, name_len);
4047 params = 6 + name_len;
4048 data_count = sizeof (struct file_end_of_file_info);
4049 pSMB->MaxParameterCount = cpu_to_le16(2);
4050 pSMB->MaxDataCount = cpu_to_le16(4100);
4051 pSMB->MaxSetupCount = 0;
4055 pSMB->Reserved2 = 0;
4056 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4057 InformationLevel) - 4;
4058 offset = param_offset + params;
4060 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4061 pSMB->InformationLevel =
4062 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4064 pSMB->InformationLevel =
4065 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4066 } else /* Set File Size */ {
4067 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4068 pSMB->InformationLevel =
4069 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4071 pSMB->InformationLevel =
4072 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4076 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4078 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4079 pSMB->DataOffset = cpu_to_le16(offset);
4080 pSMB->SetupCount = 1;
4081 pSMB->Reserved3 = 0;
4082 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4083 byte_count = 3 /* pad */ + params + data_count;
4084 pSMB->DataCount = cpu_to_le16(data_count);
4085 pSMB->TotalDataCount = pSMB->DataCount;
4086 pSMB->ParameterCount = cpu_to_le16(params);
4087 pSMB->TotalParameterCount = pSMB->ParameterCount;
4088 pSMB->Reserved4 = 0;
4089 pSMB->hdr.smb_buf_length += byte_count;
4090 parm_data->FileSize = cpu_to_le64(size);
4091 pSMB->ByteCount = cpu_to_le16(byte_count);
4092 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4093 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4095 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4098 cifs_buf_release(pSMB);
4107 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4108 __u16 fid, __u32 pid_of_opener, int SetAllocation)
4110 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4111 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4113 struct file_end_of_file_info *parm_data;
4115 int bytes_returned = 0;
4116 __u16 params, param_offset, offset, byte_count, count;
4118 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4120 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4125 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4127 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4128 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4131 pSMB->MaxSetupCount = 0;
4135 pSMB->Reserved2 = 0;
4136 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4137 offset = param_offset + params;
4139 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4141 count = sizeof(struct file_end_of_file_info);
4142 pSMB->MaxParameterCount = cpu_to_le16(2);
4143 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4144 pSMB->SetupCount = 1;
4145 pSMB->Reserved3 = 0;
4146 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4147 byte_count = 3 /* pad */ + params + count;
4148 pSMB->DataCount = cpu_to_le16(count);
4149 pSMB->ParameterCount = cpu_to_le16(params);
4150 pSMB->TotalDataCount = pSMB->DataCount;
4151 pSMB->TotalParameterCount = pSMB->ParameterCount;
4152 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4154 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4156 pSMB->DataOffset = cpu_to_le16(offset);
4157 parm_data->FileSize = cpu_to_le64(size);
4160 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4161 pSMB->InformationLevel =
4162 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4164 pSMB->InformationLevel =
4165 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4166 } else /* Set File Size */ {
4167 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4168 pSMB->InformationLevel =
4169 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4171 pSMB->InformationLevel =
4172 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4174 pSMB->Reserved4 = 0;
4175 pSMB->hdr.smb_buf_length += byte_count;
4176 pSMB->ByteCount = cpu_to_le16(byte_count);
4177 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4178 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4181 ("Send error in SetFileInfo (SetFileSize) = %d",
4186 cifs_small_buf_release(pSMB);
4188 /* Note: On -EAGAIN error only caller can retry on handle based calls
4189 since file handle passed in no longer valid */
4194 /* Some legacy servers such as NT4 require that the file times be set on
4195 an open handle, rather than by pathname - this is awkward due to
4196 potential access conflicts on the open, but it is unavoidable for these
4197 old servers since the only other choice is to go from 100 nanosecond DCE
4198 time and resort to the original setpathinfo level which takes the ancient
4199 DOS time format with 2 second granularity */
4201 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data,
4204 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4205 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4208 int bytes_returned = 0;
4209 __u16 params, param_offset, offset, byte_count, count;
4211 cFYI(1, ("Set Times (via SetFileInfo)"));
4212 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4217 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4219 /* At this point there is no need to override the current pid
4220 with the pid of the opener, but that could change if we someday
4221 use an existing handle (rather than opening one on the fly) */
4222 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4223 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
4226 pSMB->MaxSetupCount = 0;
4230 pSMB->Reserved2 = 0;
4231 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4232 offset = param_offset + params;
4234 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4236 count = sizeof (FILE_BASIC_INFO);
4237 pSMB->MaxParameterCount = cpu_to_le16(2);
4238 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4239 pSMB->SetupCount = 1;
4240 pSMB->Reserved3 = 0;
4241 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4242 byte_count = 3 /* pad */ + params + count;
4243 pSMB->DataCount = cpu_to_le16(count);
4244 pSMB->ParameterCount = cpu_to_le16(params);
4245 pSMB->TotalDataCount = pSMB->DataCount;
4246 pSMB->TotalParameterCount = pSMB->ParameterCount;
4247 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4248 pSMB->DataOffset = cpu_to_le16(offset);
4250 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4251 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4253 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4254 pSMB->Reserved4 = 0;
4255 pSMB->hdr.smb_buf_length += byte_count;
4256 pSMB->ByteCount = cpu_to_le16(byte_count);
4257 memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
4258 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4259 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4261 cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
4264 cifs_small_buf_release(pSMB);
4266 /* Note: On -EAGAIN error only caller can retry on handle based calls
4267 since file handle passed in no longer valid */
4274 CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4275 const FILE_BASIC_INFO * data,
4276 const struct nls_table *nls_codepage, int remap)
4278 TRANSACTION2_SPI_REQ *pSMB = NULL;
4279 TRANSACTION2_SPI_RSP *pSMBr = NULL;
4282 int bytes_returned = 0;
4284 __u16 params, param_offset, offset, byte_count, count;
4286 cFYI(1, ("In SetTimes"));
4289 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4294 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4296 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4297 PATH_MAX, nls_codepage, remap);
4298 name_len++; /* trailing null */
4300 } else { /* BB improve the check for buffer overruns BB */
4301 name_len = strnlen(fileName, PATH_MAX);
4302 name_len++; /* trailing null */
4303 strncpy(pSMB->FileName, fileName, name_len);
4306 params = 6 + name_len;
4307 count = sizeof (FILE_BASIC_INFO);
4308 pSMB->MaxParameterCount = cpu_to_le16(2);
4309 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4310 pSMB->MaxSetupCount = 0;
4314 pSMB->Reserved2 = 0;
4315 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4316 InformationLevel) - 4;
4317 offset = param_offset + params;
4318 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4319 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4320 pSMB->DataOffset = cpu_to_le16(offset);
4321 pSMB->SetupCount = 1;
4322 pSMB->Reserved3 = 0;
4323 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4324 byte_count = 3 /* pad */ + params + count;
4326 pSMB->DataCount = cpu_to_le16(count);
4327 pSMB->ParameterCount = cpu_to_le16(params);
4328 pSMB->TotalDataCount = pSMB->DataCount;
4329 pSMB->TotalParameterCount = pSMB->ParameterCount;
4330 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4331 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4333 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4334 pSMB->Reserved4 = 0;
4335 pSMB->hdr.smb_buf_length += byte_count;
4336 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
4337 pSMB->ByteCount = cpu_to_le16(byte_count);
4338 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4339 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4341 cFYI(1, ("SetPathInfo (times) returned %d", rc));
4344 cifs_buf_release(pSMB);
4352 /* Can not be used to set time stamps yet (due to old DOS time format) */
4353 /* Can be used to set attributes */
4354 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
4355 handling it anyway and NT4 was what we thought it would be needed for
4356 Do not delete it until we prove whether needed for Win9x though */
4358 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
4359 __u16 dos_attrs, const struct nls_table *nls_codepage)
4361 SETATTR_REQ *pSMB = NULL;
4362 SETATTR_RSP *pSMBr = NULL;
4367 cFYI(1, ("In SetAttrLegacy"));
4370 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
4375 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4377 ConvertToUCS((__le16 *) pSMB->fileName, fileName,
4378 PATH_MAX, nls_codepage);
4379 name_len++; /* trailing null */
4381 } else { /* BB improve the check for buffer overruns BB */
4382 name_len = strnlen(fileName, PATH_MAX);
4383 name_len++; /* trailing null */
4384 strncpy(pSMB->fileName, fileName, name_len);
4386 pSMB->attr = cpu_to_le16(dos_attrs);
4387 pSMB->BufferFormat = 0x04;
4388 pSMB->hdr.smb_buf_length += name_len + 1;
4389 pSMB->ByteCount = cpu_to_le16(name_len + 1);
4390 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4391 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4393 cFYI(1, ("Error in LegacySetAttr = %d", rc));
4396 cifs_buf_release(pSMB);
4399 goto SetAttrLgcyRetry;
4403 #endif /* temporarily unneeded SetAttr legacy function */
4406 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
4407 char *fileName, __u64 mode, __u64 uid, __u64 gid,
4408 dev_t device, const struct nls_table *nls_codepage,
4411 TRANSACTION2_SPI_REQ *pSMB = NULL;
4412 TRANSACTION2_SPI_RSP *pSMBr = NULL;
4415 int bytes_returned = 0;
4416 FILE_UNIX_BASIC_INFO *data_offset;
4417 __u16 params, param_offset, offset, count, byte_count;
4419 cFYI(1, ("In SetUID/GID/Mode"));
4421 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4426 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4428 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4429 PATH_MAX, nls_codepage, remap);
4430 name_len++; /* trailing null */
4432 } else { /* BB improve the check for buffer overruns BB */
4433 name_len = strnlen(fileName, PATH_MAX);
4434 name_len++; /* trailing null */
4435 strncpy(pSMB->FileName, fileName, name_len);
4438 params = 6 + name_len;
4439 count = sizeof (FILE_UNIX_BASIC_INFO);
4440 pSMB->MaxParameterCount = cpu_to_le16(2);
4441 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4442 pSMB->MaxSetupCount = 0;
4446 pSMB->Reserved2 = 0;
4447 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4448 InformationLevel) - 4;
4449 offset = param_offset + params;
4451 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
4453 memset(data_offset, 0, count);
4454 pSMB->DataOffset = cpu_to_le16(offset);
4455 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4456 pSMB->SetupCount = 1;
4457 pSMB->Reserved3 = 0;
4458 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4459 byte_count = 3 /* pad */ + params + count;
4460 pSMB->ParameterCount = cpu_to_le16(params);
4461 pSMB->DataCount = cpu_to_le16(count);
4462 pSMB->TotalParameterCount = pSMB->ParameterCount;
4463 pSMB->TotalDataCount = pSMB->DataCount;
4464 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
4465 pSMB->Reserved4 = 0;
4466 pSMB->hdr.smb_buf_length += byte_count;
4467 data_offset->Uid = cpu_to_le64(uid);
4468 data_offset->Gid = cpu_to_le64(gid);
4469 /* better to leave device as zero when it is */
4470 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
4471 data_offset->DevMinor = cpu_to_le64(MINOR(device));
4472 data_offset->Permissions = cpu_to_le64(mode);
4475 data_offset->Type = cpu_to_le32(UNIX_FILE);
4476 else if(S_ISDIR(mode))
4477 data_offset->Type = cpu_to_le32(UNIX_DIR);
4478 else if(S_ISLNK(mode))
4479 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
4480 else if(S_ISCHR(mode))
4481 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
4482 else if(S_ISBLK(mode))
4483 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
4484 else if(S_ISFIFO(mode))
4485 data_offset->Type = cpu_to_le32(UNIX_FIFO);
4486 else if(S_ISSOCK(mode))
4487 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
4490 pSMB->ByteCount = cpu_to_le16(byte_count);
4491 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4492 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4494 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
4498 cifs_buf_release(pSMB);
4504 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
4505 const int notify_subdirs, const __u16 netfid,
4506 __u32 filter, struct file * pfile, int multishot,
4507 const struct nls_table *nls_codepage)
4510 struct smb_com_transaction_change_notify_req * pSMB = NULL;
4511 struct smb_com_ntransaction_change_notify_rsp * pSMBr = NULL;
4512 struct dir_notify_req *dnotify_req;
4515 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
4516 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
4521 pSMB->TotalParameterCount = 0 ;
4522 pSMB->TotalDataCount = 0;
4523 pSMB->MaxParameterCount = cpu_to_le32(2);
4524 /* BB find exact data count max from sess structure BB */
4525 pSMB->MaxDataCount = 0; /* same in little endian or be */
4526 /* BB VERIFY verify which is correct for above BB */
4527 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
4528 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
4530 pSMB->MaxSetupCount = 4;
4532 pSMB->ParameterOffset = 0;
4533 pSMB->DataCount = 0;
4534 pSMB->DataOffset = 0;
4535 pSMB->SetupCount = 4; /* single byte does not need le conversion */
4536 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
4537 pSMB->ParameterCount = pSMB->TotalParameterCount;
4539 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
4540 pSMB->Reserved2 = 0;
4541 pSMB->CompletionFilter = cpu_to_le32(filter);
4542 pSMB->Fid = netfid; /* file handle always le */
4543 pSMB->ByteCount = 0;
4545 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4546 (struct smb_hdr *) pSMBr, &bytes_returned, -1);
4548 cFYI(1, ("Error in Notify = %d", rc));
4550 /* Add file to outstanding requests */
4551 /* BB change to kmem cache alloc */
4552 dnotify_req = (struct dir_notify_req *) kmalloc(
4553 sizeof(struct dir_notify_req),
4556 dnotify_req->Pid = pSMB->hdr.Pid;
4557 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
4558 dnotify_req->Mid = pSMB->hdr.Mid;
4559 dnotify_req->Tid = pSMB->hdr.Tid;
4560 dnotify_req->Uid = pSMB->hdr.Uid;
4561 dnotify_req->netfid = netfid;
4562 dnotify_req->pfile = pfile;
4563 dnotify_req->filter = filter;
4564 dnotify_req->multishot = multishot;
4565 spin_lock(&GlobalMid_Lock);
4566 list_add_tail(&dnotify_req->lhead,
4567 &GlobalDnotifyReqList);
4568 spin_unlock(&GlobalMid_Lock);
4572 cifs_buf_release(pSMB);
4575 #ifdef CONFIG_CIFS_XATTR
4577 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
4578 const unsigned char *searchName,
4579 char * EAData, size_t buf_size,
4580 const struct nls_table *nls_codepage, int remap)
4582 /* BB assumes one setup word */
4583 TRANSACTION2_QPI_REQ *pSMB = NULL;
4584 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4588 struct fea * temp_fea;
4590 __u16 params, byte_count;
4592 cFYI(1, ("In Query All EAs path %s", searchName));
4594 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4599 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4601 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
4602 PATH_MAX, nls_codepage, remap);
4603 name_len++; /* trailing null */
4605 } else { /* BB improve the check for buffer overruns BB */
4606 name_len = strnlen(searchName, PATH_MAX);
4607 name_len++; /* trailing null */
4608 strncpy(pSMB->FileName, searchName, name_len);
4611 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4612 pSMB->TotalDataCount = 0;
4613 pSMB->MaxParameterCount = cpu_to_le16(2);
4614 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4615 pSMB->MaxSetupCount = 0;
4619 pSMB->Reserved2 = 0;
4620 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4621 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
4622 pSMB->DataCount = 0;
4623 pSMB->DataOffset = 0;
4624 pSMB->SetupCount = 1;
4625 pSMB->Reserved3 = 0;
4626 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4627 byte_count = params + 1 /* pad */ ;
4628 pSMB->TotalParameterCount = cpu_to_le16(params);
4629 pSMB->ParameterCount = pSMB->TotalParameterCount;
4630 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
4631 pSMB->Reserved4 = 0;
4632 pSMB->hdr.smb_buf_length += byte_count;
4633 pSMB->ByteCount = cpu_to_le16(byte_count);
4635 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4636 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4638 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
4639 } else { /* decode response */
4640 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4642 /* BB also check enough total bytes returned */
4643 /* BB we need to improve the validity checking
4644 of these trans2 responses */
4645 if (rc || (pSMBr->ByteCount < 4))
4646 rc = -EIO; /* bad smb */
4647 /* else if (pFindData){
4648 memcpy((char *) pFindData,
4649 (char *) &pSMBr->hdr.Protocol +
4652 /* check that length of list is not more than bcc */
4653 /* check that each entry does not go beyond length
4655 /* check that each element of each entry does not
4656 go beyond end of list */
4657 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4658 struct fealist * ea_response_data;
4660 /* validate_trans2_offsets() */
4661 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4662 ea_response_data = (struct fealist *)
4663 (((char *) &pSMBr->hdr.Protocol) +
4665 name_len = le32_to_cpu(ea_response_data->list_len);
4666 cFYI(1,("ea length %d", name_len));
4668 /* returned EA size zeroed at top of function */
4669 cFYI(1,("empty EA list returned from server"));
4671 /* account for ea list len */
4673 temp_fea = ea_response_data->list;
4674 temp_ptr = (char *)temp_fea;
4675 while(name_len > 0) {
4679 rc += temp_fea->name_len;
4680 /* account for prefix user. and trailing null */
4682 if(rc<(int)buf_size) {
4683 memcpy(EAData,"user.",5);
4685 memcpy(EAData,temp_ptr,temp_fea->name_len);
4686 EAData+=temp_fea->name_len;
4687 /* null terminate name */
4689 EAData = EAData + 1;
4690 } else if(buf_size == 0) {
4691 /* skip copy - calc size only */
4693 /* stop before overrun buffer */
4697 name_len -= temp_fea->name_len;
4698 temp_ptr += temp_fea->name_len;
4699 /* account for trailing null */
4702 value_len = le16_to_cpu(temp_fea->value_len);
4703 name_len -= value_len;
4704 temp_ptr += value_len;
4705 /* BB check that temp_ptr is still within smb BB*/
4706 /* no trailing null to account for in value len */
4707 /* go on to next EA */
4708 temp_fea = (struct fea *)temp_ptr;
4714 cifs_buf_release(pSMB);
4721 ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
4722 const unsigned char * searchName,const unsigned char * ea_name,
4723 unsigned char * ea_value, size_t buf_size,
4724 const struct nls_table *nls_codepage, int remap)
4726 TRANSACTION2_QPI_REQ *pSMB = NULL;
4727 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4731 struct fea * temp_fea;
4733 __u16 params, byte_count;
4735 cFYI(1, ("In Query EA path %s", searchName));
4737 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4742 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4744 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
4745 PATH_MAX, nls_codepage, remap);
4746 name_len++; /* trailing null */
4748 } else { /* BB improve the check for buffer overruns BB */
4749 name_len = strnlen(searchName, PATH_MAX);
4750 name_len++; /* trailing null */
4751 strncpy(pSMB->FileName, searchName, name_len);
4754 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4755 pSMB->TotalDataCount = 0;
4756 pSMB->MaxParameterCount = cpu_to_le16(2);
4757 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4758 pSMB->MaxSetupCount = 0;
4762 pSMB->Reserved2 = 0;
4763 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4764 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
4765 pSMB->DataCount = 0;
4766 pSMB->DataOffset = 0;
4767 pSMB->SetupCount = 1;
4768 pSMB->Reserved3 = 0;
4769 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4770 byte_count = params + 1 /* pad */ ;
4771 pSMB->TotalParameterCount = cpu_to_le16(params);
4772 pSMB->ParameterCount = pSMB->TotalParameterCount;
4773 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
4774 pSMB->Reserved4 = 0;
4775 pSMB->hdr.smb_buf_length += byte_count;
4776 pSMB->ByteCount = cpu_to_le16(byte_count);
4778 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4779 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4781 cFYI(1, ("Send error in Query EA = %d", rc));
4782 } else { /* decode response */
4783 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4785 /* BB also check enough total bytes returned */
4786 /* BB we need to improve the validity checking
4787 of these trans2 responses */
4788 if (rc || (pSMBr->ByteCount < 4))
4789 rc = -EIO; /* bad smb */
4790 /* else if (pFindData){
4791 memcpy((char *) pFindData,
4792 (char *) &pSMBr->hdr.Protocol +
4795 /* check that length of list is not more than bcc */
4796 /* check that each entry does not go beyond length
4798 /* check that each element of each entry does not
4799 go beyond end of list */
4800 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4801 struct fealist * ea_response_data;
4803 /* validate_trans2_offsets() */
4804 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4805 ea_response_data = (struct fealist *)
4806 (((char *) &pSMBr->hdr.Protocol) +
4808 name_len = le32_to_cpu(ea_response_data->list_len);
4809 cFYI(1,("ea length %d", name_len));
4811 /* returned EA size zeroed at top of function */
4812 cFYI(1,("empty EA list returned from server"));
4814 /* account for ea list len */
4816 temp_fea = ea_response_data->list;
4817 temp_ptr = (char *)temp_fea;
4818 /* loop through checking if we have a matching
4819 name and then return the associated value */
4820 while(name_len > 0) {
4824 value_len = le16_to_cpu(temp_fea->value_len);
4825 /* BB validate that value_len falls within SMB,
4826 even though maximum for name_len is 255 */
4827 if(memcmp(temp_fea->name,ea_name,
4828 temp_fea->name_len) == 0) {
4831 /* account for prefix user. and trailing null */
4832 if(rc<=(int)buf_size) {
4834 temp_fea->name+temp_fea->name_len+1,
4836 /* ea values, unlike ea names,
4837 are not null terminated */
4838 } else if(buf_size == 0) {
4839 /* skip copy - calc size only */
4841 /* stop before overrun buffer */
4846 name_len -= temp_fea->name_len;
4847 temp_ptr += temp_fea->name_len;
4848 /* account for trailing null */
4851 name_len -= value_len;
4852 temp_ptr += value_len;
4853 /* no trailing null to account for in value len */
4854 /* go on to next EA */
4855 temp_fea = (struct fea *)temp_ptr;
4861 cifs_buf_release(pSMB);
4869 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4870 const char * ea_name, const void * ea_value,
4871 const __u16 ea_value_len, const struct nls_table *nls_codepage,
4874 struct smb_com_transaction2_spi_req *pSMB = NULL;
4875 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4876 struct fealist *parm_data;
4879 int bytes_returned = 0;
4880 __u16 params, param_offset, byte_count, offset, count;
4882 cFYI(1, ("In SetEA"));
4884 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4889 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4891 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4892 PATH_MAX, nls_codepage, remap);
4893 name_len++; /* trailing null */
4895 } else { /* BB improve the check for buffer overruns BB */
4896 name_len = strnlen(fileName, PATH_MAX);
4897 name_len++; /* trailing null */
4898 strncpy(pSMB->FileName, fileName, name_len);
4901 params = 6 + name_len;
4903 /* done calculating parms using name_len of file name,
4904 now use name_len to calculate length of ea name
4905 we are going to create in the inode xattrs */
4909 name_len = strnlen(ea_name,255);
4911 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
4912 pSMB->MaxParameterCount = cpu_to_le16(2);
4913 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
4914 pSMB->MaxSetupCount = 0;
4918 pSMB->Reserved2 = 0;
4919 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4920 InformationLevel) - 4;
4921 offset = param_offset + params;
4922 pSMB->InformationLevel =
4923 cpu_to_le16(SMB_SET_FILE_EA);
4926 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
4928 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4929 pSMB->DataOffset = cpu_to_le16(offset);
4930 pSMB->SetupCount = 1;
4931 pSMB->Reserved3 = 0;
4932 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4933 byte_count = 3 /* pad */ + params + count;
4934 pSMB->DataCount = cpu_to_le16(count);
4935 parm_data->list_len = cpu_to_le32(count);
4936 parm_data->list[0].EA_flags = 0;
4937 /* we checked above that name len is less than 255 */
4938 parm_data->list[0].name_len = (__u8)name_len;;
4939 /* EA names are always ASCII */
4941 strncpy(parm_data->list[0].name,ea_name,name_len);
4942 parm_data->list[0].name[name_len] = 0;
4943 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
4944 /* caller ensures that ea_value_len is less than 64K but
4945 we need to ensure that it fits within the smb */
4947 /*BB add length check that it would fit in negotiated SMB buffer size BB */
4948 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
4950 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
4952 pSMB->TotalDataCount = pSMB->DataCount;
4953 pSMB->ParameterCount = cpu_to_le16(params);
4954 pSMB->TotalParameterCount = pSMB->ParameterCount;
4955 pSMB->Reserved4 = 0;
4956 pSMB->hdr.smb_buf_length += byte_count;
4957 pSMB->ByteCount = cpu_to_le16(byte_count);
4958 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4959 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4961 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
4964 cifs_buf_release(pSMB);