ACPI: Make Len Brown the ACPI maintainer again
[linux-2.6/next.git] / fs / cifs / cifssmb.c
blob994de7c90474708ab5ed381bfc833a65d57e8c47
1 /*
2 * fs/cifs/cifssmb.c
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Contains the routines for constructing the SMB PDUs themselves
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c */
25 /* These are mostly routines that operate on a pathname, or on a tree id */
26 /* (mounted volume), but there are eight handle based routines which must be */
27 /* treated slightly differently for reconnection purposes since we never */
28 /* want to reuse a stale file handle and only the caller knows the file info */
30 #include <linux/fs.h>
31 #include <linux/kernel.h>
32 #include <linux/vfs.h>
33 #include <linux/posix_acl_xattr.h>
34 #include <asm/uaccess.h>
35 #include "cifspdu.h"
36 #include "cifsglob.h"
37 #include "cifsacl.h"
38 #include "cifsproto.h"
39 #include "cifs_unicode.h"
40 #include "cifs_debug.h"
42 #ifdef CONFIG_CIFS_POSIX
43 static struct {
44 int index;
45 char *name;
46 } protocols[] = {
47 #ifdef CONFIG_CIFS_WEAK_PW_HASH
48 {LANMAN_PROT, "\2LM1.2X002"},
49 {LANMAN2_PROT, "\2LANMAN2.1"},
50 #endif /* weak password hashing for legacy clients */
51 {CIFS_PROT, "\2NT LM 0.12"},
52 {POSIX_PROT, "\2POSIX 2"},
53 {BAD_PROT, "\2"}
55 #else
56 static struct {
57 int index;
58 char *name;
59 } protocols[] = {
60 #ifdef CONFIG_CIFS_WEAK_PW_HASH
61 {LANMAN_PROT, "\2LM1.2X002"},
62 {LANMAN2_PROT, "\2LANMAN2.1"},
63 #endif /* weak password hashing for legacy clients */
64 {CIFS_PROT, "\2NT LM 0.12"},
65 {BAD_PROT, "\2"}
67 #endif
69 /* define the number of elements in the cifs dialect array */
70 #ifdef CONFIG_CIFS_POSIX
71 #ifdef CONFIG_CIFS_WEAK_PW_HASH
72 #define CIFS_NUM_PROT 4
73 #else
74 #define CIFS_NUM_PROT 2
75 #endif /* CIFS_WEAK_PW_HASH */
76 #else /* not posix */
77 #ifdef CONFIG_CIFS_WEAK_PW_HASH
78 #define CIFS_NUM_PROT 3
79 #else
80 #define CIFS_NUM_PROT 1
81 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
82 #endif /* CIFS_POSIX */
84 /* Allocates buffer into dst and copies smb string from src to it.
85 * caller is responsible for freeing dst if function returned 0.
86 * returns:
87 * on success - 0
88 * on failure - errno
90 static int
91 cifs_strncpy_to_host(char **dst, const char *src, const int maxlen,
92 const bool is_unicode, const struct nls_table *nls_codepage)
94 int plen;
96 if (is_unicode) {
97 plen = UniStrnlen((wchar_t *)src, maxlen);
98 *dst = kmalloc(plen + 2, GFP_KERNEL);
99 if (!*dst)
100 goto cifs_strncpy_to_host_ErrExit;
101 cifs_strfromUCS_le(*dst, (__le16 *)src, plen, nls_codepage);
102 } else {
103 plen = strnlen(src, maxlen);
104 *dst = kmalloc(plen + 2, GFP_KERNEL);
105 if (!*dst)
106 goto cifs_strncpy_to_host_ErrExit;
107 strncpy(*dst, src, plen);
109 (*dst)[plen] = 0;
110 (*dst)[plen+1] = 0; /* harmless for ASCII case, needed for Unicode */
111 return 0;
113 cifs_strncpy_to_host_ErrExit:
114 cERROR(1, ("Failed to allocate buffer for string\n"));
115 return -ENOMEM;
119 /* Mark as invalid, all open files on tree connections since they
120 were closed when session to server was lost */
121 static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
123 struct cifsFileInfo *open_file = NULL;
124 struct list_head *tmp;
125 struct list_head *tmp1;
127 /* list all files open on tree connection and mark them invalid */
128 write_lock(&GlobalSMBSeslock);
129 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
130 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
131 open_file->invalidHandle = true;
133 write_unlock(&GlobalSMBSeslock);
134 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
135 to this tcon */
138 /* Allocate and return pointer to an SMB request buffer, and set basic
139 SMB information in the SMB header. If the return code is zero, this
140 function must have filled in request_buf pointer */
141 static int
142 small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
143 void **request_buf)
145 int rc = 0;
147 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
148 check for tcp and smb session status done differently
149 for those three - in the calling routine */
150 if (tcon) {
151 if (tcon->tidStatus == CifsExiting) {
152 /* only tree disconnect, open, and write,
153 (and ulogoff which does not have tcon)
154 are allowed as we start force umount */
155 if ((smb_command != SMB_COM_WRITE_ANDX) &&
156 (smb_command != SMB_COM_OPEN_ANDX) &&
157 (smb_command != SMB_COM_TREE_DISCONNECT)) {
158 cFYI(1, ("can not send cmd %d while umounting",
159 smb_command));
160 return -ENODEV;
163 if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
164 (tcon->ses->server)) {
165 struct nls_table *nls_codepage;
166 /* Give Demultiplex thread up to 10 seconds to
167 reconnect, should be greater than cifs socket
168 timeout which is 7 seconds */
169 while (tcon->ses->server->tcpStatus ==
170 CifsNeedReconnect) {
171 wait_event_interruptible_timeout(tcon->ses->server->response_q,
172 (tcon->ses->server->tcpStatus ==
173 CifsGood), 10 * HZ);
174 if (tcon->ses->server->tcpStatus ==
175 CifsNeedReconnect) {
176 /* on "soft" mounts we wait once */
177 if (!tcon->retry ||
178 (tcon->ses->status == CifsExiting)) {
179 cFYI(1, ("gave up waiting on "
180 "reconnect in smb_init"));
181 return -EHOSTDOWN;
182 } /* else "hard" mount - keep retrying
183 until process is killed or server
184 comes back on-line */
185 } else /* TCP session is reestablished now */
186 break;
189 nls_codepage = load_nls_default();
190 /* need to prevent multiple threads trying to
191 simultaneously reconnect the same SMB session */
192 down(&tcon->ses->sesSem);
193 if (tcon->ses->status == CifsNeedReconnect)
194 rc = cifs_setup_session(0, tcon->ses,
195 nls_codepage);
196 if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
197 mark_open_files_invalid(tcon);
198 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
199 tcon, nls_codepage);
200 up(&tcon->ses->sesSem);
201 /* BB FIXME add code to check if wsize needs
202 update due to negotiated smb buffer size
203 shrinking */
204 if (rc == 0) {
205 atomic_inc(&tconInfoReconnectCount);
206 /* tell server Unix caps we support */
207 if (tcon->ses->capabilities & CAP_UNIX)
208 reset_cifs_unix_caps(
209 0 /* no xid */,
210 tcon,
211 NULL /* we do not know sb */,
212 NULL /* no vol info */);
215 cFYI(1, ("reconnect tcon rc = %d", rc));
216 /* Removed call to reopen open files here.
217 It is safer (and faster) to reopen files
218 one at a time as needed in read and write */
220 /* Check if handle based operation so we
221 know whether we can continue or not without
222 returning to caller to reset file handle */
223 switch (smb_command) {
224 case SMB_COM_READ_ANDX:
225 case SMB_COM_WRITE_ANDX:
226 case SMB_COM_CLOSE:
227 case SMB_COM_FIND_CLOSE2:
228 case SMB_COM_LOCKING_ANDX: {
229 unload_nls(nls_codepage);
230 return -EAGAIN;
233 } else {
234 up(&tcon->ses->sesSem);
236 unload_nls(nls_codepage);
238 } else {
239 return -EIO;
242 if (rc)
243 return rc;
245 *request_buf = cifs_small_buf_get();
246 if (*request_buf == NULL) {
247 /* BB should we add a retry in here if not a writepage? */
248 return -ENOMEM;
251 header_assemble((struct smb_hdr *) *request_buf, smb_command,
252 tcon, wct);
254 if (tcon != NULL)
255 cifs_stats_inc(&tcon->num_smbs_sent);
257 return rc;
261 small_smb_init_no_tc(const int smb_command, const int wct,
262 struct cifsSesInfo *ses, void **request_buf)
264 int rc;
265 struct smb_hdr *buffer;
267 rc = small_smb_init(smb_command, wct, NULL, request_buf);
268 if (rc)
269 return rc;
271 buffer = (struct smb_hdr *)*request_buf;
272 buffer->Mid = GetNextMid(ses->server);
273 if (ses->capabilities & CAP_UNICODE)
274 buffer->Flags2 |= SMBFLG2_UNICODE;
275 if (ses->capabilities & CAP_STATUS32)
276 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
278 /* uid, tid can stay at zero as set in header assemble */
280 /* BB add support for turning on the signing when
281 this function is used after 1st of session setup requests */
283 return rc;
286 /* If the return code is zero, this function must fill in request_buf pointer */
287 static int
288 smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
289 void **request_buf /* returned */ ,
290 void **response_buf /* returned */ )
292 int rc = 0;
294 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
295 check for tcp and smb session status done differently
296 for those three - in the calling routine */
297 if (tcon) {
298 if (tcon->tidStatus == CifsExiting) {
299 /* only tree disconnect, open, and write,
300 (and ulogoff which does not have tcon)
301 are allowed as we start force umount */
302 if ((smb_command != SMB_COM_WRITE_ANDX) &&
303 (smb_command != SMB_COM_OPEN_ANDX) &&
304 (smb_command != SMB_COM_TREE_DISCONNECT)) {
305 cFYI(1, ("can not send cmd %d while umounting",
306 smb_command));
307 return -ENODEV;
311 if ((tcon->ses) && (tcon->ses->status != CifsExiting) &&
312 (tcon->ses->server)) {
313 struct nls_table *nls_codepage;
314 /* Give Demultiplex thread up to 10 seconds to
315 reconnect, should be greater than cifs socket
316 timeout which is 7 seconds */
317 while (tcon->ses->server->tcpStatus ==
318 CifsNeedReconnect) {
319 wait_event_interruptible_timeout(tcon->ses->server->response_q,
320 (tcon->ses->server->tcpStatus ==
321 CifsGood), 10 * HZ);
322 if (tcon->ses->server->tcpStatus ==
323 CifsNeedReconnect) {
324 /* on "soft" mounts we wait once */
325 if (!tcon->retry ||
326 (tcon->ses->status == CifsExiting)) {
327 cFYI(1, ("gave up waiting on "
328 "reconnect in smb_init"));
329 return -EHOSTDOWN;
330 } /* else "hard" mount - keep retrying
331 until process is killed or server
332 comes on-line */
333 } else /* TCP session is reestablished now */
334 break;
336 nls_codepage = load_nls_default();
337 /* need to prevent multiple threads trying to
338 simultaneously reconnect the same SMB session */
339 down(&tcon->ses->sesSem);
340 if (tcon->ses->status == CifsNeedReconnect)
341 rc = cifs_setup_session(0, tcon->ses,
342 nls_codepage);
343 if (!rc && (tcon->tidStatus == CifsNeedReconnect)) {
344 mark_open_files_invalid(tcon);
345 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
346 tcon, nls_codepage);
347 up(&tcon->ses->sesSem);
348 /* BB FIXME add code to check if wsize needs
349 update due to negotiated smb buffer size
350 shrinking */
351 if (rc == 0) {
352 atomic_inc(&tconInfoReconnectCount);
353 /* tell server Unix caps we support */
354 if (tcon->ses->capabilities & CAP_UNIX)
355 reset_cifs_unix_caps(
356 0 /* no xid */,
357 tcon,
358 NULL /* do not know sb */,
359 NULL /* no vol info */);
362 cFYI(1, ("reconnect tcon rc = %d", rc));
363 /* Removed call to reopen open files here.
364 It is safer (and faster) to reopen files
365 one at a time as needed in read and write */
367 /* Check if handle based operation so we
368 know whether we can continue or not without
369 returning to caller to reset file handle */
370 switch (smb_command) {
371 case SMB_COM_READ_ANDX:
372 case SMB_COM_WRITE_ANDX:
373 case SMB_COM_CLOSE:
374 case SMB_COM_FIND_CLOSE2:
375 case SMB_COM_LOCKING_ANDX: {
376 unload_nls(nls_codepage);
377 return -EAGAIN;
380 } else {
381 up(&tcon->ses->sesSem);
383 unload_nls(nls_codepage);
385 } else {
386 return -EIO;
389 if (rc)
390 return rc;
392 *request_buf = cifs_buf_get();
393 if (*request_buf == NULL) {
394 /* BB should we add a retry in here if not a writepage? */
395 return -ENOMEM;
397 /* Although the original thought was we needed the response buf for */
398 /* potential retries of smb operations it turns out we can determine */
399 /* from the mid flags when the request buffer can be resent without */
400 /* having to use a second distinct buffer for the response */
401 if (response_buf)
402 *response_buf = *request_buf;
404 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
405 wct);
407 if (tcon != NULL)
408 cifs_stats_inc(&tcon->num_smbs_sent);
410 return rc;
413 static int validate_t2(struct smb_t2_rsp *pSMB)
415 int rc = -EINVAL;
416 int total_size;
417 char *pBCC;
419 /* check for plausible wct, bcc and t2 data and parm sizes */
420 /* check for parm and data offset going beyond end of smb */
421 if (pSMB->hdr.WordCount >= 10) {
422 if ((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
423 (le16_to_cpu(pSMB->t2_rsp.DataOffset) <= 1024)) {
424 /* check that bcc is at least as big as parms + data */
425 /* check that bcc is less than negotiated smb buffer */
426 total_size = le16_to_cpu(pSMB->t2_rsp.ParameterCount);
427 if (total_size < 512) {
428 total_size +=
429 le16_to_cpu(pSMB->t2_rsp.DataCount);
430 /* BCC le converted in SendReceive */
431 pBCC = (pSMB->hdr.WordCount * 2) +
432 sizeof(struct smb_hdr) +
433 (char *)pSMB;
434 if ((total_size <= (*(u16 *)pBCC)) &&
435 (total_size <
436 CIFSMaxBufSize+MAX_CIFS_HDR_SIZE)) {
437 return 0;
442 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
443 sizeof(struct smb_t2_rsp) + 16);
444 return rc;
447 CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
449 NEGOTIATE_REQ *pSMB;
450 NEGOTIATE_RSP *pSMBr;
451 int rc = 0;
452 int bytes_returned;
453 int i;
454 struct TCP_Server_Info *server;
455 u16 count;
456 unsigned int secFlags;
457 u16 dialect;
459 if (ses->server)
460 server = ses->server;
461 else {
462 rc = -EIO;
463 return rc;
465 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
466 (void **) &pSMB, (void **) &pSMBr);
467 if (rc)
468 return rc;
470 /* if any of auth flags (ie not sign or seal) are overriden use them */
471 if (ses->overrideSecFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
472 secFlags = ses->overrideSecFlg; /* BB FIXME fix sign flags? */
473 else /* if override flags set only sign/seal OR them with global auth */
474 secFlags = extended_security | ses->overrideSecFlg;
476 cFYI(1, ("secFlags 0x%x", secFlags));
478 pSMB->hdr.Mid = GetNextMid(server);
479 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
481 if ((secFlags & CIFSSEC_MUST_KRB5) == CIFSSEC_MUST_KRB5)
482 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
483 else if ((secFlags & CIFSSEC_AUTH_MASK) == CIFSSEC_MAY_KRB5) {
484 cFYI(1, ("Kerberos only mechanism, enable extended security"));
485 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
488 count = 0;
489 for (i = 0; i < CIFS_NUM_PROT; i++) {
490 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
491 count += strlen(protocols[i].name) + 1;
492 /* null at end of source and target buffers anyway */
494 pSMB->hdr.smb_buf_length += count;
495 pSMB->ByteCount = cpu_to_le16(count);
497 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
498 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
499 if (rc != 0)
500 goto neg_err_exit;
502 dialect = le16_to_cpu(pSMBr->DialectIndex);
503 cFYI(1, ("Dialect: %d", dialect));
504 /* Check wct = 1 error case */
505 if ((pSMBr->hdr.WordCount < 13) || (dialect == BAD_PROT)) {
506 /* core returns wct = 1, but we do not ask for core - otherwise
507 small wct just comes when dialect index is -1 indicating we
508 could not negotiate a common dialect */
509 rc = -EOPNOTSUPP;
510 goto neg_err_exit;
511 #ifdef CONFIG_CIFS_WEAK_PW_HASH
512 } else if ((pSMBr->hdr.WordCount == 13)
513 && ((dialect == LANMAN_PROT)
514 || (dialect == LANMAN2_PROT))) {
515 __s16 tmp;
516 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
518 if ((secFlags & CIFSSEC_MAY_LANMAN) ||
519 (secFlags & CIFSSEC_MAY_PLNTXT))
520 server->secType = LANMAN;
521 else {
522 cERROR(1, ("mount failed weak security disabled"
523 " in /proc/fs/cifs/SecurityFlags"));
524 rc = -EOPNOTSUPP;
525 goto neg_err_exit;
527 server->secMode = (__u8)le16_to_cpu(rsp->SecurityMode);
528 server->maxReq = le16_to_cpu(rsp->MaxMpxCount);
529 server->maxBuf = min((__u32)le16_to_cpu(rsp->MaxBufSize),
530 (__u32)CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
531 GETU32(server->sessid) = le32_to_cpu(rsp->SessionKey);
532 /* even though we do not use raw we might as well set this
533 accurately, in case we ever find a need for it */
534 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
535 server->maxRw = 0xFF00;
536 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
537 } else {
538 server->maxRw = 0;/* we do not need to use raw anyway */
539 server->capabilities = CAP_MPX_MODE;
541 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
542 if (tmp == -1) {
543 /* OS/2 often does not set timezone therefore
544 * we must use server time to calc time zone.
545 * Could deviate slightly from the right zone.
546 * Smallest defined timezone difference is 15 minutes
547 * (i.e. Nepal). Rounding up/down is done to match
548 * this requirement.
550 int val, seconds, remain, result;
551 struct timespec ts, utc;
552 utc = CURRENT_TIME;
553 ts = cnvrtDosUnixTm(le16_to_cpu(rsp->SrvTime.Date),
554 le16_to_cpu(rsp->SrvTime.Time));
555 cFYI(1, ("SrvTime %d sec since 1970 (utc: %d) diff: %d",
556 (int)ts.tv_sec, (int)utc.tv_sec,
557 (int)(utc.tv_sec - ts.tv_sec)));
558 val = (int)(utc.tv_sec - ts.tv_sec);
559 seconds = abs(val);
560 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
561 remain = seconds % MIN_TZ_ADJ;
562 if (remain >= (MIN_TZ_ADJ / 2))
563 result += MIN_TZ_ADJ;
564 if (val < 0)
565 result = -result;
566 server->timeAdj = result;
567 } else {
568 server->timeAdj = (int)tmp;
569 server->timeAdj *= 60; /* also in seconds */
571 cFYI(1, ("server->timeAdj: %d seconds", server->timeAdj));
574 /* BB get server time for time conversions and add
575 code to use it and timezone since this is not UTC */
577 if (rsp->EncryptionKeyLength ==
578 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
579 memcpy(server->cryptKey, rsp->EncryptionKey,
580 CIFS_CRYPTO_KEY_SIZE);
581 } else if (server->secMode & SECMODE_PW_ENCRYPT) {
582 rc = -EIO; /* need cryptkey unless plain text */
583 goto neg_err_exit;
586 cFYI(1, ("LANMAN negotiated"));
587 /* we will not end up setting signing flags - as no signing
588 was in LANMAN and server did not return the flags on */
589 goto signing_check;
590 #else /* weak security disabled */
591 } else if (pSMBr->hdr.WordCount == 13) {
592 cERROR(1, ("mount failed, cifs module not built "
593 "with CIFS_WEAK_PW_HASH support"));
594 rc = -EOPNOTSUPP;
595 #endif /* WEAK_PW_HASH */
596 goto neg_err_exit;
597 } else if (pSMBr->hdr.WordCount != 17) {
598 /* unknown wct */
599 rc = -EOPNOTSUPP;
600 goto neg_err_exit;
602 /* else wct == 17 NTLM */
603 server->secMode = pSMBr->SecurityMode;
604 if ((server->secMode & SECMODE_USER) == 0)
605 cFYI(1, ("share mode security"));
607 if ((server->secMode & SECMODE_PW_ENCRYPT) == 0)
608 #ifdef CONFIG_CIFS_WEAK_PW_HASH
609 if ((secFlags & CIFSSEC_MAY_PLNTXT) == 0)
610 #endif /* CIFS_WEAK_PW_HASH */
611 cERROR(1, ("Server requests plain text password"
612 " but client support disabled"));
614 if ((secFlags & CIFSSEC_MUST_NTLMV2) == CIFSSEC_MUST_NTLMV2)
615 server->secType = NTLMv2;
616 else if (secFlags & CIFSSEC_MAY_NTLM)
617 server->secType = NTLM;
618 else if (secFlags & CIFSSEC_MAY_NTLMV2)
619 server->secType = NTLMv2;
620 else if (secFlags & CIFSSEC_MAY_KRB5)
621 server->secType = Kerberos;
622 else if (secFlags & CIFSSEC_MAY_LANMAN)
623 server->secType = LANMAN;
624 /* #ifdef CONFIG_CIFS_EXPERIMENTAL
625 else if (secFlags & CIFSSEC_MAY_PLNTXT)
626 server->secType = ??
627 #endif */
628 else {
629 rc = -EOPNOTSUPP;
630 cERROR(1, ("Invalid security type"));
631 goto neg_err_exit;
633 /* else ... any others ...? */
635 /* one byte, so no need to convert this or EncryptionKeyLen from
636 little endian */
637 server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
638 /* probably no need to store and check maxvcs */
639 server->maxBuf = min(le32_to_cpu(pSMBr->MaxBufferSize),
640 (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
641 server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
642 cFYI(DBG2, ("Max buf = %d", ses->server->maxBuf));
643 GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
644 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
645 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
646 server->timeAdj *= 60;
647 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
648 memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
649 CIFS_CRYPTO_KEY_SIZE);
650 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
651 && (pSMBr->EncryptionKeyLength == 0)) {
652 /* decode security blob */
653 } else if (server->secMode & SECMODE_PW_ENCRYPT) {
654 rc = -EIO; /* no crypt key only if plain text pwd */
655 goto neg_err_exit;
658 /* BB might be helpful to save off the domain of server here */
660 if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
661 (server->capabilities & CAP_EXTENDED_SECURITY)) {
662 count = pSMBr->ByteCount;
663 if (count < 16) {
664 rc = -EIO;
665 goto neg_err_exit;
668 if (server->socketUseCount.counter > 1) {
669 if (memcmp(server->server_GUID,
670 pSMBr->u.extended_response.
671 GUID, 16) != 0) {
672 cFYI(1, ("server UID changed"));
673 memcpy(server->server_GUID,
674 pSMBr->u.extended_response.GUID,
675 16);
677 } else
678 memcpy(server->server_GUID,
679 pSMBr->u.extended_response.GUID, 16);
681 if (count == 16) {
682 server->secType = RawNTLMSSP;
683 } else {
684 rc = decode_negTokenInit(pSMBr->u.extended_response.
685 SecurityBlob,
686 count - 16,
687 &server->secType);
688 if (rc == 1)
689 rc = 0;
690 else
691 rc = -EINVAL;
693 } else
694 server->capabilities &= ~CAP_EXTENDED_SECURITY;
696 #ifdef CONFIG_CIFS_WEAK_PW_HASH
697 signing_check:
698 #endif
699 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
700 /* MUST_SIGN already includes the MAY_SIGN FLAG
701 so if this is zero it means that signing is disabled */
702 cFYI(1, ("Signing disabled"));
703 if (server->secMode & SECMODE_SIGN_REQUIRED) {
704 cERROR(1, ("Server requires "
705 "packet signing to be enabled in "
706 "/proc/fs/cifs/SecurityFlags."));
707 rc = -EOPNOTSUPP;
709 server->secMode &=
710 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
711 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
712 /* signing required */
713 cFYI(1, ("Must sign - secFlags 0x%x", secFlags));
714 if ((server->secMode &
715 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
716 cERROR(1,
717 ("signing required but server lacks support"));
718 rc = -EOPNOTSUPP;
719 } else
720 server->secMode |= SECMODE_SIGN_REQUIRED;
721 } else {
722 /* signing optional ie CIFSSEC_MAY_SIGN */
723 if ((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
724 server->secMode &=
725 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
728 neg_err_exit:
729 cifs_buf_release(pSMB);
731 cFYI(1, ("negprot rc %d", rc));
732 return rc;
736 CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
738 struct smb_hdr *smb_buffer;
739 int rc = 0;
741 cFYI(1, ("In tree disconnect"));
743 * If last user of the connection and
744 * connection alive - disconnect it
745 * If this is the last connection on the server session disconnect it
746 * (and inside session disconnect we should check if tcp socket needs
747 * to be freed and kernel thread woken up).
749 if (tcon)
750 down(&tcon->tconSem);
751 else
752 return -EIO;
754 atomic_dec(&tcon->useCount);
755 if (atomic_read(&tcon->useCount) > 0) {
756 up(&tcon->tconSem);
757 return -EBUSY;
760 /* No need to return error on this operation if tid invalidated and
761 closed on server already e.g. due to tcp session crashing */
762 if (tcon->tidStatus == CifsNeedReconnect) {
763 up(&tcon->tconSem);
764 return 0;
767 if ((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
768 up(&tcon->tconSem);
769 return -EIO;
771 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
772 (void **)&smb_buffer);
773 if (rc) {
774 up(&tcon->tconSem);
775 return rc;
778 rc = SendReceiveNoRsp(xid, tcon->ses, smb_buffer, 0);
779 if (rc)
780 cFYI(1, ("Tree disconnect failed %d", rc));
782 up(&tcon->tconSem);
784 /* No need to return error on this operation if tid invalidated and
785 closed on server already e.g. due to tcp session crashing */
786 if (rc == -EAGAIN)
787 rc = 0;
789 return rc;
793 CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
795 LOGOFF_ANDX_REQ *pSMB;
796 int rc = 0;
798 cFYI(1, ("In SMBLogoff for session disconnect"));
799 if (ses)
800 down(&ses->sesSem);
801 else
802 return -EIO;
804 atomic_dec(&ses->inUse);
805 if (atomic_read(&ses->inUse) > 0) {
806 up(&ses->sesSem);
807 return -EBUSY;
809 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
810 if (rc) {
811 up(&ses->sesSem);
812 return rc;
815 if (ses->server) {
816 pSMB->hdr.Mid = GetNextMid(ses->server);
818 if (ses->server->secMode &
819 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
820 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
823 pSMB->hdr.Uid = ses->Suid;
825 pSMB->AndXCommand = 0xFF;
826 rc = SendReceiveNoRsp(xid, ses, (struct smb_hdr *) pSMB, 0);
827 if (ses->server) {
828 atomic_dec(&ses->server->socketUseCount);
829 if (atomic_read(&ses->server->socketUseCount) == 0) {
830 spin_lock(&GlobalMid_Lock);
831 ses->server->tcpStatus = CifsExiting;
832 spin_unlock(&GlobalMid_Lock);
833 rc = -ESHUTDOWN;
836 up(&ses->sesSem);
838 /* if session dead then we do not need to do ulogoff,
839 since server closed smb session, no sense reporting
840 error */
841 if (rc == -EAGAIN)
842 rc = 0;
843 return rc;
847 CIFSPOSIXDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
848 __u16 type, const struct nls_table *nls_codepage, int remap)
850 TRANSACTION2_SPI_REQ *pSMB = NULL;
851 TRANSACTION2_SPI_RSP *pSMBr = NULL;
852 struct unlink_psx_rq *pRqD;
853 int name_len;
854 int rc = 0;
855 int bytes_returned = 0;
856 __u16 params, param_offset, offset, byte_count;
858 cFYI(1, ("In POSIX delete"));
859 PsxDelete:
860 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
861 (void **) &pSMBr);
862 if (rc)
863 return rc;
865 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
866 name_len =
867 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
868 PATH_MAX, nls_codepage, remap);
869 name_len++; /* trailing null */
870 name_len *= 2;
871 } else { /* BB add path length overrun check */
872 name_len = strnlen(fileName, PATH_MAX);
873 name_len++; /* trailing null */
874 strncpy(pSMB->FileName, fileName, name_len);
877 params = 6 + name_len;
878 pSMB->MaxParameterCount = cpu_to_le16(2);
879 pSMB->MaxDataCount = 0; /* BB double check this with jra */
880 pSMB->MaxSetupCount = 0;
881 pSMB->Reserved = 0;
882 pSMB->Flags = 0;
883 pSMB->Timeout = 0;
884 pSMB->Reserved2 = 0;
885 param_offset = offsetof(struct smb_com_transaction2_spi_req,
886 InformationLevel) - 4;
887 offset = param_offset + params;
889 /* Setup pointer to Request Data (inode type) */
890 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
891 pRqD->type = cpu_to_le16(type);
892 pSMB->ParameterOffset = cpu_to_le16(param_offset);
893 pSMB->DataOffset = cpu_to_le16(offset);
894 pSMB->SetupCount = 1;
895 pSMB->Reserved3 = 0;
896 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
897 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
899 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
900 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
901 pSMB->ParameterCount = cpu_to_le16(params);
902 pSMB->TotalParameterCount = pSMB->ParameterCount;
903 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
904 pSMB->Reserved4 = 0;
905 pSMB->hdr.smb_buf_length += byte_count;
906 pSMB->ByteCount = cpu_to_le16(byte_count);
907 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
908 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
909 if (rc)
910 cFYI(1, ("Posix delete returned %d", rc));
911 cifs_buf_release(pSMB);
913 cifs_stats_inc(&tcon->num_deletes);
915 if (rc == -EAGAIN)
916 goto PsxDelete;
918 return rc;
922 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
923 const struct nls_table *nls_codepage, int remap)
925 DELETE_FILE_REQ *pSMB = NULL;
926 DELETE_FILE_RSP *pSMBr = NULL;
927 int rc = 0;
928 int bytes_returned;
929 int name_len;
931 DelFileRetry:
932 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
933 (void **) &pSMBr);
934 if (rc)
935 return rc;
937 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
938 name_len =
939 cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
940 PATH_MAX, nls_codepage, remap);
941 name_len++; /* trailing null */
942 name_len *= 2;
943 } else { /* BB improve check for buffer overruns BB */
944 name_len = strnlen(fileName, PATH_MAX);
945 name_len++; /* trailing null */
946 strncpy(pSMB->fileName, fileName, name_len);
948 pSMB->SearchAttributes =
949 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
950 pSMB->BufferFormat = 0x04;
951 pSMB->hdr.smb_buf_length += name_len + 1;
952 pSMB->ByteCount = cpu_to_le16(name_len + 1);
953 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
954 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
955 cifs_stats_inc(&tcon->num_deletes);
956 if (rc)
957 cFYI(1, ("Error in RMFile = %d", rc));
959 cifs_buf_release(pSMB);
960 if (rc == -EAGAIN)
961 goto DelFileRetry;
963 return rc;
967 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
968 const struct nls_table *nls_codepage, int remap)
970 DELETE_DIRECTORY_REQ *pSMB = NULL;
971 DELETE_DIRECTORY_RSP *pSMBr = NULL;
972 int rc = 0;
973 int bytes_returned;
974 int name_len;
976 cFYI(1, ("In CIFSSMBRmDir"));
977 RmDirRetry:
978 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
979 (void **) &pSMBr);
980 if (rc)
981 return rc;
983 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
984 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
985 PATH_MAX, nls_codepage, remap);
986 name_len++; /* trailing null */
987 name_len *= 2;
988 } else { /* BB improve check for buffer overruns BB */
989 name_len = strnlen(dirName, PATH_MAX);
990 name_len++; /* trailing null */
991 strncpy(pSMB->DirName, dirName, name_len);
994 pSMB->BufferFormat = 0x04;
995 pSMB->hdr.smb_buf_length += name_len + 1;
996 pSMB->ByteCount = cpu_to_le16(name_len + 1);
997 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
998 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
999 cifs_stats_inc(&tcon->num_rmdirs);
1000 if (rc)
1001 cFYI(1, ("Error in RMDir = %d", rc));
1003 cifs_buf_release(pSMB);
1004 if (rc == -EAGAIN)
1005 goto RmDirRetry;
1006 return rc;
1010 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
1011 const char *name, const struct nls_table *nls_codepage, int remap)
1013 int rc = 0;
1014 CREATE_DIRECTORY_REQ *pSMB = NULL;
1015 CREATE_DIRECTORY_RSP *pSMBr = NULL;
1016 int bytes_returned;
1017 int name_len;
1019 cFYI(1, ("In CIFSSMBMkDir"));
1020 MkDirRetry:
1021 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
1022 (void **) &pSMBr);
1023 if (rc)
1024 return rc;
1026 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1027 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
1028 PATH_MAX, nls_codepage, remap);
1029 name_len++; /* trailing null */
1030 name_len *= 2;
1031 } else { /* BB improve check for buffer overruns BB */
1032 name_len = strnlen(name, PATH_MAX);
1033 name_len++; /* trailing null */
1034 strncpy(pSMB->DirName, name, name_len);
1037 pSMB->BufferFormat = 0x04;
1038 pSMB->hdr.smb_buf_length += name_len + 1;
1039 pSMB->ByteCount = cpu_to_le16(name_len + 1);
1040 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1041 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1042 cifs_stats_inc(&tcon->num_mkdirs);
1043 if (rc)
1044 cFYI(1, ("Error in Mkdir = %d", rc));
1046 cifs_buf_release(pSMB);
1047 if (rc == -EAGAIN)
1048 goto MkDirRetry;
1049 return rc;
1053 CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
1054 __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
1055 __u32 *pOplock, const char *name,
1056 const struct nls_table *nls_codepage, int remap)
1058 TRANSACTION2_SPI_REQ *pSMB = NULL;
1059 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1060 int name_len;
1061 int rc = 0;
1062 int bytes_returned = 0;
1063 __u16 params, param_offset, offset, byte_count, count;
1064 OPEN_PSX_REQ *pdata;
1065 OPEN_PSX_RSP *psx_rsp;
1067 cFYI(1, ("In POSIX Create"));
1068 PsxCreat:
1069 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1070 (void **) &pSMBr);
1071 if (rc)
1072 return rc;
1074 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1075 name_len =
1076 cifsConvertToUCS((__le16 *) pSMB->FileName, name,
1077 PATH_MAX, nls_codepage, remap);
1078 name_len++; /* trailing null */
1079 name_len *= 2;
1080 } else { /* BB improve the check for buffer overruns BB */
1081 name_len = strnlen(name, PATH_MAX);
1082 name_len++; /* trailing null */
1083 strncpy(pSMB->FileName, name, name_len);
1086 params = 6 + name_len;
1087 count = sizeof(OPEN_PSX_REQ);
1088 pSMB->MaxParameterCount = cpu_to_le16(2);
1089 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1090 pSMB->MaxSetupCount = 0;
1091 pSMB->Reserved = 0;
1092 pSMB->Flags = 0;
1093 pSMB->Timeout = 0;
1094 pSMB->Reserved2 = 0;
1095 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1096 InformationLevel) - 4;
1097 offset = param_offset + params;
1098 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1099 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1100 pdata->Permissions = cpu_to_le64(mode);
1101 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1102 pdata->OpenFlags = cpu_to_le32(*pOplock);
1103 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1104 pSMB->DataOffset = cpu_to_le16(offset);
1105 pSMB->SetupCount = 1;
1106 pSMB->Reserved3 = 0;
1107 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1108 byte_count = 3 /* pad */ + params + count;
1110 pSMB->DataCount = cpu_to_le16(count);
1111 pSMB->ParameterCount = cpu_to_le16(params);
1112 pSMB->TotalDataCount = pSMB->DataCount;
1113 pSMB->TotalParameterCount = pSMB->ParameterCount;
1114 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1115 pSMB->Reserved4 = 0;
1116 pSMB->hdr.smb_buf_length += byte_count;
1117 pSMB->ByteCount = cpu_to_le16(byte_count);
1118 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1119 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1120 if (rc) {
1121 cFYI(1, ("Posix create returned %d", rc));
1122 goto psx_create_err;
1125 cFYI(1, ("copying inode info"));
1126 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1128 if (rc || (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP))) {
1129 rc = -EIO; /* bad smb */
1130 goto psx_create_err;
1133 /* copy return information to pRetData */
1134 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1135 + le16_to_cpu(pSMBr->t2.DataOffset));
1137 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1138 if (netfid)
1139 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1140 /* Let caller know file was created so we can set the mode. */
1141 /* Do we care about the CreateAction in any other cases? */
1142 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1143 *pOplock |= CIFS_CREATE_ACTION;
1144 /* check to make sure response data is there */
1145 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1146 pRetData->Type = cpu_to_le32(-1); /* unknown */
1147 cFYI(DBG2, ("unknown type"));
1148 } else {
1149 if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
1150 + sizeof(FILE_UNIX_BASIC_INFO)) {
1151 cERROR(1, ("Open response data too small"));
1152 pRetData->Type = cpu_to_le32(-1);
1153 goto psx_create_err;
1155 memcpy((char *) pRetData,
1156 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1157 sizeof(FILE_UNIX_BASIC_INFO));
1160 psx_create_err:
1161 cifs_buf_release(pSMB);
1163 cifs_stats_inc(&tcon->num_mkdirs);
1165 if (rc == -EAGAIN)
1166 goto PsxCreat;
1168 return rc;
1171 static __u16 convert_disposition(int disposition)
1173 __u16 ofun = 0;
1175 switch (disposition) {
1176 case FILE_SUPERSEDE:
1177 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1178 break;
1179 case FILE_OPEN:
1180 ofun = SMBOPEN_OAPPEND;
1181 break;
1182 case FILE_CREATE:
1183 ofun = SMBOPEN_OCREATE;
1184 break;
1185 case FILE_OPEN_IF:
1186 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1187 break;
1188 case FILE_OVERWRITE:
1189 ofun = SMBOPEN_OTRUNC;
1190 break;
1191 case FILE_OVERWRITE_IF:
1192 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1193 break;
1194 default:
1195 cFYI(1, ("unknown disposition %d", disposition));
1196 ofun = SMBOPEN_OAPPEND; /* regular open */
1198 return ofun;
1201 static int
1202 access_flags_to_smbopen_mode(const int access_flags)
1204 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1206 if (masked_flags == GENERIC_READ)
1207 return SMBOPEN_READ;
1208 else if (masked_flags == GENERIC_WRITE)
1209 return SMBOPEN_WRITE;
1211 /* just go for read/write */
1212 return SMBOPEN_READWRITE;
1216 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
1217 const char *fileName, const int openDisposition,
1218 const int access_flags, const int create_options, __u16 *netfid,
1219 int *pOplock, FILE_ALL_INFO *pfile_info,
1220 const struct nls_table *nls_codepage, int remap)
1222 int rc = -EACCES;
1223 OPENX_REQ *pSMB = NULL;
1224 OPENX_RSP *pSMBr = NULL;
1225 int bytes_returned;
1226 int name_len;
1227 __u16 count;
1229 OldOpenRetry:
1230 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1231 (void **) &pSMBr);
1232 if (rc)
1233 return rc;
1235 pSMB->AndXCommand = 0xFF; /* none */
1237 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1238 count = 1; /* account for one byte pad to word boundary */
1239 name_len =
1240 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1241 fileName, PATH_MAX, nls_codepage, remap);
1242 name_len++; /* trailing null */
1243 name_len *= 2;
1244 } else { /* BB improve check for buffer overruns BB */
1245 count = 0; /* no pad */
1246 name_len = strnlen(fileName, PATH_MAX);
1247 name_len++; /* trailing null */
1248 strncpy(pSMB->fileName, fileName, name_len);
1250 if (*pOplock & REQ_OPLOCK)
1251 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1252 else if (*pOplock & REQ_BATCHOPLOCK)
1253 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1255 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1256 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1257 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1258 /* set file as system file if special file such
1259 as fifo and server expecting SFU style and
1260 no Unix extensions */
1262 if (create_options & CREATE_OPTION_SPECIAL)
1263 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1264 else /* BB FIXME BB */
1265 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1267 if (create_options & CREATE_OPTION_READONLY)
1268 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1270 /* BB FIXME BB */
1271 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1272 CREATE_OPTIONS_MASK); */
1273 /* BB FIXME END BB */
1275 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1276 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1277 count += name_len;
1278 pSMB->hdr.smb_buf_length += count;
1280 pSMB->ByteCount = cpu_to_le16(count);
1281 /* long_op set to 1 to allow for oplock break timeouts */
1282 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1283 (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1284 cifs_stats_inc(&tcon->num_opens);
1285 if (rc) {
1286 cFYI(1, ("Error in Open = %d", rc));
1287 } else {
1288 /* BB verify if wct == 15 */
1290 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1292 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1293 /* Let caller know file was created so we can set the mode. */
1294 /* Do we care about the CreateAction in any other cases? */
1295 /* BB FIXME BB */
1296 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1297 *pOplock |= CIFS_CREATE_ACTION; */
1298 /* BB FIXME END */
1300 if (pfile_info) {
1301 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1302 pfile_info->LastAccessTime = 0; /* BB fixme */
1303 pfile_info->LastWriteTime = 0; /* BB fixme */
1304 pfile_info->ChangeTime = 0; /* BB fixme */
1305 pfile_info->Attributes =
1306 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1307 /* the file_info buf is endian converted by caller */
1308 pfile_info->AllocationSize =
1309 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1310 pfile_info->EndOfFile = pfile_info->AllocationSize;
1311 pfile_info->NumberOfLinks = cpu_to_le32(1);
1315 cifs_buf_release(pSMB);
1316 if (rc == -EAGAIN)
1317 goto OldOpenRetry;
1318 return rc;
1322 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
1323 const char *fileName, const int openDisposition,
1324 const int access_flags, const int create_options, __u16 *netfid,
1325 int *pOplock, FILE_ALL_INFO *pfile_info,
1326 const struct nls_table *nls_codepage, int remap)
1328 int rc = -EACCES;
1329 OPEN_REQ *pSMB = NULL;
1330 OPEN_RSP *pSMBr = NULL;
1331 int bytes_returned;
1332 int name_len;
1333 __u16 count;
1335 openRetry:
1336 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1337 (void **) &pSMBr);
1338 if (rc)
1339 return rc;
1341 pSMB->AndXCommand = 0xFF; /* none */
1343 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1344 count = 1; /* account for one byte pad to word boundary */
1345 name_len =
1346 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1347 fileName, PATH_MAX, nls_codepage, remap);
1348 name_len++; /* trailing null */
1349 name_len *= 2;
1350 pSMB->NameLength = cpu_to_le16(name_len);
1351 } else { /* BB improve check for buffer overruns BB */
1352 count = 0; /* no pad */
1353 name_len = strnlen(fileName, PATH_MAX);
1354 name_len++; /* trailing null */
1355 pSMB->NameLength = cpu_to_le16(name_len);
1356 strncpy(pSMB->fileName, fileName, name_len);
1358 if (*pOplock & REQ_OPLOCK)
1359 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1360 else if (*pOplock & REQ_BATCHOPLOCK)
1361 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1362 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1363 pSMB->AllocationSize = 0;
1364 /* set file as system file if special file such
1365 as fifo and server expecting SFU style and
1366 no Unix extensions */
1367 if (create_options & CREATE_OPTION_SPECIAL)
1368 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1369 else
1370 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1372 /* XP does not handle ATTR_POSIX_SEMANTICS */
1373 /* but it helps speed up case sensitive checks for other
1374 servers such as Samba */
1375 if (tcon->ses->capabilities & CAP_UNIX)
1376 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1378 if (create_options & CREATE_OPTION_READONLY)
1379 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1381 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1382 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1383 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1384 /* BB Expirement with various impersonation levels and verify */
1385 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1386 pSMB->SecurityFlags =
1387 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1389 count += name_len;
1390 pSMB->hdr.smb_buf_length += count;
1392 pSMB->ByteCount = cpu_to_le16(count);
1393 /* long_op set to 1 to allow for oplock break timeouts */
1394 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1395 (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1396 cifs_stats_inc(&tcon->num_opens);
1397 if (rc) {
1398 cFYI(1, ("Error in Open = %d", rc));
1399 } else {
1400 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1401 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1402 /* Let caller know file was created so we can set the mode. */
1403 /* Do we care about the CreateAction in any other cases? */
1404 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1405 *pOplock |= CIFS_CREATE_ACTION;
1406 if (pfile_info) {
1407 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1408 36 /* CreationTime to Attributes */);
1409 /* the file_info buf is endian converted by caller */
1410 pfile_info->AllocationSize = pSMBr->AllocationSize;
1411 pfile_info->EndOfFile = pSMBr->EndOfFile;
1412 pfile_info->NumberOfLinks = cpu_to_le32(1);
1416 cifs_buf_release(pSMB);
1417 if (rc == -EAGAIN)
1418 goto openRetry;
1419 return rc;
1423 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
1424 const unsigned int count, const __u64 lseek, unsigned int *nbytes,
1425 char **buf, int *pbuf_type)
1427 int rc = -EACCES;
1428 READ_REQ *pSMB = NULL;
1429 READ_RSP *pSMBr = NULL;
1430 char *pReadData = NULL;
1431 int wct;
1432 int resp_buf_type = 0;
1433 struct kvec iov[1];
1435 cFYI(1, ("Reading %d bytes on fid %d", count, netfid));
1436 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1437 wct = 12;
1438 else
1439 wct = 10; /* old style read */
1441 *nbytes = 0;
1442 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1443 if (rc)
1444 return rc;
1446 /* tcon and ses pointer are checked in smb_init */
1447 if (tcon->ses->server == NULL)
1448 return -ECONNABORTED;
1450 pSMB->AndXCommand = 0xFF; /* none */
1451 pSMB->Fid = netfid;
1452 pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
1453 if (wct == 12)
1454 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
1455 else if ((lseek >> 32) > 0) /* can not handle this big offset for old */
1456 return -EIO;
1458 pSMB->Remaining = 0;
1459 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1460 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1461 if (wct == 12)
1462 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1463 else {
1464 /* old style read */
1465 struct smb_com_readx_req *pSMBW =
1466 (struct smb_com_readx_req *)pSMB;
1467 pSMBW->ByteCount = 0;
1470 iov[0].iov_base = (char *)pSMB;
1471 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1472 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1473 &resp_buf_type, CIFS_STD_OP | CIFS_LOG_ERROR);
1474 cifs_stats_inc(&tcon->num_reads);
1475 pSMBr = (READ_RSP *)iov[0].iov_base;
1476 if (rc) {
1477 cERROR(1, ("Send error in read = %d", rc));
1478 } else {
1479 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1480 data_length = data_length << 16;
1481 data_length += le16_to_cpu(pSMBr->DataLength);
1482 *nbytes = data_length;
1484 /*check that DataLength would not go beyond end of SMB */
1485 if ((data_length > CIFSMaxBufSize)
1486 || (data_length > count)) {
1487 cFYI(1, ("bad length %d for count %d",
1488 data_length, count));
1489 rc = -EIO;
1490 *nbytes = 0;
1491 } else {
1492 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1493 le16_to_cpu(pSMBr->DataOffset);
1494 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1495 cERROR(1,("Faulting on read rc = %d",rc));
1496 rc = -EFAULT;
1497 }*/ /* can not use copy_to_user when using page cache*/
1498 if (*buf)
1499 memcpy(*buf, pReadData, data_length);
1503 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1504 if (*buf) {
1505 if (resp_buf_type == CIFS_SMALL_BUFFER)
1506 cifs_small_buf_release(iov[0].iov_base);
1507 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1508 cifs_buf_release(iov[0].iov_base);
1509 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1510 /* return buffer to caller to free */
1511 *buf = iov[0].iov_base;
1512 if (resp_buf_type == CIFS_SMALL_BUFFER)
1513 *pbuf_type = CIFS_SMALL_BUFFER;
1514 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1515 *pbuf_type = CIFS_LARGE_BUFFER;
1516 } /* else no valid buffer on return - leave as null */
1518 /* Note: On -EAGAIN error only caller can retry on handle based calls
1519 since file handle passed in no longer valid */
1520 return rc;
1525 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
1526 const int netfid, const unsigned int count,
1527 const __u64 offset, unsigned int *nbytes, const char *buf,
1528 const char __user *ubuf, const int long_op)
1530 int rc = -EACCES;
1531 WRITE_REQ *pSMB = NULL;
1532 WRITE_RSP *pSMBr = NULL;
1533 int bytes_returned, wct;
1534 __u32 bytes_sent;
1535 __u16 byte_count;
1537 /* cFYI(1,("write at %lld %d bytes",offset,count));*/
1538 if (tcon->ses == NULL)
1539 return -ECONNABORTED;
1541 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1542 wct = 14;
1543 else
1544 wct = 12;
1546 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1547 (void **) &pSMBr);
1548 if (rc)
1549 return rc;
1550 /* tcon and ses pointer are checked in smb_init */
1551 if (tcon->ses->server == NULL)
1552 return -ECONNABORTED;
1554 pSMB->AndXCommand = 0xFF; /* none */
1555 pSMB->Fid = netfid;
1556 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1557 if (wct == 14)
1558 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1559 else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1560 return -EIO;
1562 pSMB->Reserved = 0xFFFFFFFF;
1563 pSMB->WriteMode = 0;
1564 pSMB->Remaining = 0;
1566 /* Can increase buffer size if buffer is big enough in some cases ie we
1567 can send more if LARGE_WRITE_X capability returned by the server and if
1568 our buffer is big enough or if we convert to iovecs on socket writes
1569 and eliminate the copy to the CIFS buffer */
1570 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1571 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1572 } else {
1573 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1574 & ~0xFF;
1577 if (bytes_sent > count)
1578 bytes_sent = count;
1579 pSMB->DataOffset =
1580 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1581 if (buf)
1582 memcpy(pSMB->Data, buf, bytes_sent);
1583 else if (ubuf) {
1584 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1585 cifs_buf_release(pSMB);
1586 return -EFAULT;
1588 } else if (count != 0) {
1589 /* No buffer */
1590 cifs_buf_release(pSMB);
1591 return -EINVAL;
1592 } /* else setting file size with write of zero bytes */
1593 if (wct == 14)
1594 byte_count = bytes_sent + 1; /* pad */
1595 else /* wct == 12 */
1596 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1598 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1599 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1600 pSMB->hdr.smb_buf_length += byte_count;
1602 if (wct == 14)
1603 pSMB->ByteCount = cpu_to_le16(byte_count);
1604 else { /* old style write has byte count 4 bytes earlier
1605 so 4 bytes pad */
1606 struct smb_com_writex_req *pSMBW =
1607 (struct smb_com_writex_req *)pSMB;
1608 pSMBW->ByteCount = cpu_to_le16(byte_count);
1611 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1612 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1613 cifs_stats_inc(&tcon->num_writes);
1614 if (rc) {
1615 cFYI(1, ("Send error in write = %d", rc));
1616 *nbytes = 0;
1617 } else {
1618 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1619 *nbytes = (*nbytes) << 16;
1620 *nbytes += le16_to_cpu(pSMBr->Count);
1623 cifs_buf_release(pSMB);
1625 /* Note: On -EAGAIN error only caller can retry on handle based calls
1626 since file handle passed in no longer valid */
1628 return rc;
1632 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
1633 const int netfid, const unsigned int count,
1634 const __u64 offset, unsigned int *nbytes, struct kvec *iov,
1635 int n_vec, const int long_op)
1637 int rc = -EACCES;
1638 WRITE_REQ *pSMB = NULL;
1639 int wct;
1640 int smb_hdr_len;
1641 int resp_buf_type = 0;
1643 cFYI(1, ("write2 at %lld %d bytes", (long long)offset, count));
1645 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1646 wct = 14;
1647 else
1648 wct = 12;
1649 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1650 if (rc)
1651 return rc;
1652 /* tcon and ses pointer are checked in smb_init */
1653 if (tcon->ses->server == NULL)
1654 return -ECONNABORTED;
1656 pSMB->AndXCommand = 0xFF; /* none */
1657 pSMB->Fid = netfid;
1658 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1659 if (wct == 14)
1660 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1661 else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1662 return -EIO;
1663 pSMB->Reserved = 0xFFFFFFFF;
1664 pSMB->WriteMode = 0;
1665 pSMB->Remaining = 0;
1667 pSMB->DataOffset =
1668 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1670 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1671 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1672 smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1673 if (wct == 14)
1674 pSMB->hdr.smb_buf_length += count+1;
1675 else /* wct == 12 */
1676 pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
1677 if (wct == 14)
1678 pSMB->ByteCount = cpu_to_le16(count + 1);
1679 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1680 struct smb_com_writex_req *pSMBW =
1681 (struct smb_com_writex_req *)pSMB;
1682 pSMBW->ByteCount = cpu_to_le16(count + 5);
1684 iov[0].iov_base = pSMB;
1685 if (wct == 14)
1686 iov[0].iov_len = smb_hdr_len + 4;
1687 else /* wct == 12 pad bigger by four bytes */
1688 iov[0].iov_len = smb_hdr_len + 8;
1691 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
1692 long_op);
1693 cifs_stats_inc(&tcon->num_writes);
1694 if (rc) {
1695 cFYI(1, ("Send error Write2 = %d", rc));
1696 *nbytes = 0;
1697 } else if (resp_buf_type == 0) {
1698 /* presumably this can not happen, but best to be safe */
1699 rc = -EIO;
1700 *nbytes = 0;
1701 } else {
1702 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
1703 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1704 *nbytes = (*nbytes) << 16;
1705 *nbytes += le16_to_cpu(pSMBr->Count);
1708 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1709 if (resp_buf_type == CIFS_SMALL_BUFFER)
1710 cifs_small_buf_release(iov[0].iov_base);
1711 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1712 cifs_buf_release(iov[0].iov_base);
1714 /* Note: On -EAGAIN error only caller can retry on handle based calls
1715 since file handle passed in no longer valid */
1717 return rc;
1722 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1723 const __u16 smb_file_id, const __u64 len,
1724 const __u64 offset, const __u32 numUnlock,
1725 const __u32 numLock, const __u8 lockType, const bool waitFlag)
1727 int rc = 0;
1728 LOCK_REQ *pSMB = NULL;
1729 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
1730 int bytes_returned;
1731 int timeout = 0;
1732 __u16 count;
1734 cFYI(1, ("CIFSSMBLock timeout %d numLock %d", (int)waitFlag, numLock));
1735 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1737 if (rc)
1738 return rc;
1740 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1741 timeout = CIFS_ASYNC_OP; /* no response expected */
1742 pSMB->Timeout = 0;
1743 } else if (waitFlag) {
1744 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1745 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1746 } else {
1747 pSMB->Timeout = 0;
1750 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1751 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1752 pSMB->LockType = lockType;
1753 pSMB->AndXCommand = 0xFF; /* none */
1754 pSMB->Fid = smb_file_id; /* netfid stays le */
1756 if ((numLock != 0) || (numUnlock != 0)) {
1757 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1758 /* BB where to store pid high? */
1759 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1760 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1761 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1762 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1763 count = sizeof(LOCKING_ANDX_RANGE);
1764 } else {
1765 /* oplock break */
1766 count = 0;
1768 pSMB->hdr.smb_buf_length += count;
1769 pSMB->ByteCount = cpu_to_le16(count);
1771 if (waitFlag) {
1772 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1773 (struct smb_hdr *) pSMB, &bytes_returned);
1774 cifs_small_buf_release(pSMB);
1775 } else {
1776 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
1777 timeout);
1778 /* SMB buffer freed by function above */
1780 cifs_stats_inc(&tcon->num_locks);
1781 if (rc)
1782 cFYI(1, ("Send error in Lock = %d", rc));
1784 /* Note: On -EAGAIN error only caller can retry on handle based calls
1785 since file handle passed in no longer valid */
1786 return rc;
1790 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
1791 const __u16 smb_file_id, const int get_flag, const __u64 len,
1792 struct file_lock *pLockData, const __u16 lock_type,
1793 const bool waitFlag)
1795 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1796 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1797 struct cifs_posix_lock *parm_data;
1798 int rc = 0;
1799 int timeout = 0;
1800 int bytes_returned = 0;
1801 int resp_buf_type = 0;
1802 __u16 params, param_offset, offset, byte_count, count;
1803 struct kvec iov[1];
1805 cFYI(1, ("Posix Lock"));
1807 if (pLockData == NULL)
1808 return -EINVAL;
1810 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1812 if (rc)
1813 return rc;
1815 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1817 params = 6;
1818 pSMB->MaxSetupCount = 0;
1819 pSMB->Reserved = 0;
1820 pSMB->Flags = 0;
1821 pSMB->Reserved2 = 0;
1822 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1823 offset = param_offset + params;
1825 count = sizeof(struct cifs_posix_lock);
1826 pSMB->MaxParameterCount = cpu_to_le16(2);
1827 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
1828 pSMB->SetupCount = 1;
1829 pSMB->Reserved3 = 0;
1830 if (get_flag)
1831 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
1832 else
1833 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1834 byte_count = 3 /* pad */ + params + count;
1835 pSMB->DataCount = cpu_to_le16(count);
1836 pSMB->ParameterCount = cpu_to_le16(params);
1837 pSMB->TotalDataCount = pSMB->DataCount;
1838 pSMB->TotalParameterCount = pSMB->ParameterCount;
1839 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1840 parm_data = (struct cifs_posix_lock *)
1841 (((char *) &pSMB->hdr.Protocol) + offset);
1843 parm_data->lock_type = cpu_to_le16(lock_type);
1844 if (waitFlag) {
1845 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1846 parm_data->lock_flags = cpu_to_le16(1);
1847 pSMB->Timeout = cpu_to_le32(-1);
1848 } else
1849 pSMB->Timeout = 0;
1851 parm_data->pid = cpu_to_le32(current->tgid);
1852 parm_data->start = cpu_to_le64(pLockData->fl_start);
1853 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
1855 pSMB->DataOffset = cpu_to_le16(offset);
1856 pSMB->Fid = smb_file_id;
1857 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
1858 pSMB->Reserved4 = 0;
1859 pSMB->hdr.smb_buf_length += byte_count;
1860 pSMB->ByteCount = cpu_to_le16(byte_count);
1861 if (waitFlag) {
1862 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1863 (struct smb_hdr *) pSMBr, &bytes_returned);
1864 } else {
1865 iov[0].iov_base = (char *)pSMB;
1866 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1867 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1868 &resp_buf_type, timeout);
1869 pSMB = NULL; /* request buf already freed by SendReceive2. Do
1870 not try to free it twice below on exit */
1871 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
1874 if (rc) {
1875 cFYI(1, ("Send error in Posix Lock = %d", rc));
1876 } else if (get_flag) {
1877 /* lock structure can be returned on get */
1878 __u16 data_offset;
1879 __u16 data_count;
1880 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1882 if (rc || (pSMBr->ByteCount < sizeof(struct cifs_posix_lock))) {
1883 rc = -EIO; /* bad smb */
1884 goto plk_err_exit;
1886 if (pLockData == NULL) {
1887 rc = -EINVAL;
1888 goto plk_err_exit;
1890 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1891 data_count = le16_to_cpu(pSMBr->t2.DataCount);
1892 if (data_count < sizeof(struct cifs_posix_lock)) {
1893 rc = -EIO;
1894 goto plk_err_exit;
1896 parm_data = (struct cifs_posix_lock *)
1897 ((char *)&pSMBr->hdr.Protocol + data_offset);
1898 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
1899 pLockData->fl_type = F_UNLCK;
1902 plk_err_exit:
1903 if (pSMB)
1904 cifs_small_buf_release(pSMB);
1906 if (resp_buf_type == CIFS_SMALL_BUFFER)
1907 cifs_small_buf_release(iov[0].iov_base);
1908 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1909 cifs_buf_release(iov[0].iov_base);
1911 /* Note: On -EAGAIN error only caller can retry on handle based calls
1912 since file handle passed in no longer valid */
1914 return rc;
1919 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1921 int rc = 0;
1922 CLOSE_REQ *pSMB = NULL;
1923 cFYI(1, ("In CIFSSMBClose"));
1925 /* do not retry on dead session on close */
1926 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1927 if (rc == -EAGAIN)
1928 return 0;
1929 if (rc)
1930 return rc;
1932 pSMB->FileID = (__u16) smb_file_id;
1933 pSMB->LastWriteTime = 0xFFFFFFFF;
1934 pSMB->ByteCount = 0;
1935 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
1936 cifs_stats_inc(&tcon->num_closes);
1937 if (rc) {
1938 if (rc != -EINTR) {
1939 /* EINTR is expected when user ctl-c to kill app */
1940 cERROR(1, ("Send error in Close = %d", rc));
1944 /* Since session is dead, file will be closed on server already */
1945 if (rc == -EAGAIN)
1946 rc = 0;
1948 return rc;
1952 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1953 const char *fromName, const char *toName,
1954 const struct nls_table *nls_codepage, int remap)
1956 int rc = 0;
1957 RENAME_REQ *pSMB = NULL;
1958 RENAME_RSP *pSMBr = NULL;
1959 int bytes_returned;
1960 int name_len, name_len2;
1961 __u16 count;
1963 cFYI(1, ("In CIFSSMBRename"));
1964 renameRetry:
1965 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1966 (void **) &pSMBr);
1967 if (rc)
1968 return rc;
1970 pSMB->BufferFormat = 0x04;
1971 pSMB->SearchAttributes =
1972 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1973 ATTR_DIRECTORY);
1975 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1976 name_len =
1977 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1978 PATH_MAX, nls_codepage, remap);
1979 name_len++; /* trailing null */
1980 name_len *= 2;
1981 pSMB->OldFileName[name_len] = 0x04; /* pad */
1982 /* protocol requires ASCII signature byte on Unicode string */
1983 pSMB->OldFileName[name_len + 1] = 0x00;
1984 name_len2 =
1985 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1986 toName, PATH_MAX, nls_codepage, remap);
1987 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1988 name_len2 *= 2; /* convert to bytes */
1989 } else { /* BB improve the check for buffer overruns BB */
1990 name_len = strnlen(fromName, PATH_MAX);
1991 name_len++; /* trailing null */
1992 strncpy(pSMB->OldFileName, fromName, name_len);
1993 name_len2 = strnlen(toName, PATH_MAX);
1994 name_len2++; /* trailing null */
1995 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1996 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1997 name_len2++; /* trailing null */
1998 name_len2++; /* signature byte */
2001 count = 1 /* 1st signature byte */ + name_len + name_len2;
2002 pSMB->hdr.smb_buf_length += count;
2003 pSMB->ByteCount = cpu_to_le16(count);
2005 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2006 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2007 cifs_stats_inc(&tcon->num_renames);
2008 if (rc)
2009 cFYI(1, ("Send error in rename = %d", rc));
2011 cifs_buf_release(pSMB);
2013 if (rc == -EAGAIN)
2014 goto renameRetry;
2016 return rc;
2019 int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
2020 int netfid, char *target_name,
2021 const struct nls_table *nls_codepage, int remap)
2023 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2024 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2025 struct set_file_rename *rename_info;
2026 char *data_offset;
2027 char dummy_string[30];
2028 int rc = 0;
2029 int bytes_returned = 0;
2030 int len_of_str;
2031 __u16 params, param_offset, offset, count, byte_count;
2033 cFYI(1, ("Rename to File by handle"));
2034 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2035 (void **) &pSMBr);
2036 if (rc)
2037 return rc;
2039 params = 6;
2040 pSMB->MaxSetupCount = 0;
2041 pSMB->Reserved = 0;
2042 pSMB->Flags = 0;
2043 pSMB->Timeout = 0;
2044 pSMB->Reserved2 = 0;
2045 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2046 offset = param_offset + params;
2048 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2049 rename_info = (struct set_file_rename *) data_offset;
2050 pSMB->MaxParameterCount = cpu_to_le16(2);
2051 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2052 pSMB->SetupCount = 1;
2053 pSMB->Reserved3 = 0;
2054 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2055 byte_count = 3 /* pad */ + params;
2056 pSMB->ParameterCount = cpu_to_le16(params);
2057 pSMB->TotalParameterCount = pSMB->ParameterCount;
2058 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2059 pSMB->DataOffset = cpu_to_le16(offset);
2060 /* construct random name ".cifs_tmp<inodenum><mid>" */
2061 rename_info->overwrite = cpu_to_le32(1);
2062 rename_info->root_fid = 0;
2063 /* unicode only call */
2064 if (target_name == NULL) {
2065 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2066 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2067 dummy_string, 24, nls_codepage, remap);
2068 } else {
2069 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2070 target_name, PATH_MAX, nls_codepage,
2071 remap);
2073 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2074 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
2075 byte_count += count;
2076 pSMB->DataCount = cpu_to_le16(count);
2077 pSMB->TotalDataCount = pSMB->DataCount;
2078 pSMB->Fid = netfid;
2079 pSMB->InformationLevel =
2080 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2081 pSMB->Reserved4 = 0;
2082 pSMB->hdr.smb_buf_length += byte_count;
2083 pSMB->ByteCount = cpu_to_le16(byte_count);
2084 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2085 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2086 cifs_stats_inc(&pTcon->num_t2renames);
2087 if (rc)
2088 cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
2090 cifs_buf_release(pSMB);
2092 /* Note: On -EAGAIN error only caller can retry on handle based calls
2093 since file handle passed in no longer valid */
2095 return rc;
2099 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char *fromName,
2100 const __u16 target_tid, const char *toName, const int flags,
2101 const struct nls_table *nls_codepage, int remap)
2103 int rc = 0;
2104 COPY_REQ *pSMB = NULL;
2105 COPY_RSP *pSMBr = NULL;
2106 int bytes_returned;
2107 int name_len, name_len2;
2108 __u16 count;
2110 cFYI(1, ("In CIFSSMBCopy"));
2111 copyRetry:
2112 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2113 (void **) &pSMBr);
2114 if (rc)
2115 return rc;
2117 pSMB->BufferFormat = 0x04;
2118 pSMB->Tid2 = target_tid;
2120 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2122 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2123 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
2124 fromName, PATH_MAX, nls_codepage,
2125 remap);
2126 name_len++; /* trailing null */
2127 name_len *= 2;
2128 pSMB->OldFileName[name_len] = 0x04; /* pad */
2129 /* protocol requires ASCII signature byte on Unicode string */
2130 pSMB->OldFileName[name_len + 1] = 0x00;
2131 name_len2 =
2132 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2133 toName, PATH_MAX, nls_codepage, remap);
2134 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2135 name_len2 *= 2; /* convert to bytes */
2136 } else { /* BB improve the check for buffer overruns BB */
2137 name_len = strnlen(fromName, PATH_MAX);
2138 name_len++; /* trailing null */
2139 strncpy(pSMB->OldFileName, fromName, name_len);
2140 name_len2 = strnlen(toName, PATH_MAX);
2141 name_len2++; /* trailing null */
2142 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2143 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2144 name_len2++; /* trailing null */
2145 name_len2++; /* signature byte */
2148 count = 1 /* 1st signature byte */ + name_len + name_len2;
2149 pSMB->hdr.smb_buf_length += count;
2150 pSMB->ByteCount = cpu_to_le16(count);
2152 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2153 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2154 if (rc) {
2155 cFYI(1, ("Send error in copy = %d with %d files copied",
2156 rc, le16_to_cpu(pSMBr->CopyCount)));
2158 cifs_buf_release(pSMB);
2160 if (rc == -EAGAIN)
2161 goto copyRetry;
2163 return rc;
2167 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
2168 const char *fromName, const char *toName,
2169 const struct nls_table *nls_codepage)
2171 TRANSACTION2_SPI_REQ *pSMB = NULL;
2172 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2173 char *data_offset;
2174 int name_len;
2175 int name_len_target;
2176 int rc = 0;
2177 int bytes_returned = 0;
2178 __u16 params, param_offset, offset, byte_count;
2180 cFYI(1, ("In Symlink Unix style"));
2181 createSymLinkRetry:
2182 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2183 (void **) &pSMBr);
2184 if (rc)
2185 return rc;
2187 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2188 name_len =
2189 cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
2190 /* find define for this maxpathcomponent */
2191 , nls_codepage);
2192 name_len++; /* trailing null */
2193 name_len *= 2;
2195 } else { /* BB improve the check for buffer overruns BB */
2196 name_len = strnlen(fromName, PATH_MAX);
2197 name_len++; /* trailing null */
2198 strncpy(pSMB->FileName, fromName, name_len);
2200 params = 6 + name_len;
2201 pSMB->MaxSetupCount = 0;
2202 pSMB->Reserved = 0;
2203 pSMB->Flags = 0;
2204 pSMB->Timeout = 0;
2205 pSMB->Reserved2 = 0;
2206 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2207 InformationLevel) - 4;
2208 offset = param_offset + params;
2210 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2211 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2212 name_len_target =
2213 cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
2214 /* find define for this maxpathcomponent */
2215 , nls_codepage);
2216 name_len_target++; /* trailing null */
2217 name_len_target *= 2;
2218 } else { /* BB improve the check for buffer overruns BB */
2219 name_len_target = strnlen(toName, PATH_MAX);
2220 name_len_target++; /* trailing null */
2221 strncpy(data_offset, toName, name_len_target);
2224 pSMB->MaxParameterCount = cpu_to_le16(2);
2225 /* BB find exact max on data count below from sess */
2226 pSMB->MaxDataCount = cpu_to_le16(1000);
2227 pSMB->SetupCount = 1;
2228 pSMB->Reserved3 = 0;
2229 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2230 byte_count = 3 /* pad */ + params + name_len_target;
2231 pSMB->DataCount = cpu_to_le16(name_len_target);
2232 pSMB->ParameterCount = cpu_to_le16(params);
2233 pSMB->TotalDataCount = pSMB->DataCount;
2234 pSMB->TotalParameterCount = pSMB->ParameterCount;
2235 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2236 pSMB->DataOffset = cpu_to_le16(offset);
2237 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2238 pSMB->Reserved4 = 0;
2239 pSMB->hdr.smb_buf_length += byte_count;
2240 pSMB->ByteCount = cpu_to_le16(byte_count);
2241 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2242 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2243 cifs_stats_inc(&tcon->num_symlinks);
2244 if (rc)
2245 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
2247 cifs_buf_release(pSMB);
2249 if (rc == -EAGAIN)
2250 goto createSymLinkRetry;
2252 return rc;
2256 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2257 const char *fromName, const char *toName,
2258 const struct nls_table *nls_codepage, int remap)
2260 TRANSACTION2_SPI_REQ *pSMB = NULL;
2261 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2262 char *data_offset;
2263 int name_len;
2264 int name_len_target;
2265 int rc = 0;
2266 int bytes_returned = 0;
2267 __u16 params, param_offset, offset, byte_count;
2269 cFYI(1, ("In Create Hard link Unix style"));
2270 createHardLinkRetry:
2271 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2272 (void **) &pSMBr);
2273 if (rc)
2274 return rc;
2276 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2277 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
2278 PATH_MAX, nls_codepage, remap);
2279 name_len++; /* trailing null */
2280 name_len *= 2;
2282 } else { /* BB improve the check for buffer overruns BB */
2283 name_len = strnlen(toName, PATH_MAX);
2284 name_len++; /* trailing null */
2285 strncpy(pSMB->FileName, toName, name_len);
2287 params = 6 + name_len;
2288 pSMB->MaxSetupCount = 0;
2289 pSMB->Reserved = 0;
2290 pSMB->Flags = 0;
2291 pSMB->Timeout = 0;
2292 pSMB->Reserved2 = 0;
2293 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2294 InformationLevel) - 4;
2295 offset = param_offset + params;
2297 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2298 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2299 name_len_target =
2300 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
2301 nls_codepage, remap);
2302 name_len_target++; /* trailing null */
2303 name_len_target *= 2;
2304 } else { /* BB improve the check for buffer overruns BB */
2305 name_len_target = strnlen(fromName, PATH_MAX);
2306 name_len_target++; /* trailing null */
2307 strncpy(data_offset, fromName, name_len_target);
2310 pSMB->MaxParameterCount = cpu_to_le16(2);
2311 /* BB find exact max on data count below from sess*/
2312 pSMB->MaxDataCount = cpu_to_le16(1000);
2313 pSMB->SetupCount = 1;
2314 pSMB->Reserved3 = 0;
2315 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2316 byte_count = 3 /* pad */ + params + name_len_target;
2317 pSMB->ParameterCount = cpu_to_le16(params);
2318 pSMB->TotalParameterCount = pSMB->ParameterCount;
2319 pSMB->DataCount = cpu_to_le16(name_len_target);
2320 pSMB->TotalDataCount = pSMB->DataCount;
2321 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2322 pSMB->DataOffset = cpu_to_le16(offset);
2323 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2324 pSMB->Reserved4 = 0;
2325 pSMB->hdr.smb_buf_length += byte_count;
2326 pSMB->ByteCount = cpu_to_le16(byte_count);
2327 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2328 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2329 cifs_stats_inc(&tcon->num_hardlinks);
2330 if (rc)
2331 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
2333 cifs_buf_release(pSMB);
2334 if (rc == -EAGAIN)
2335 goto createHardLinkRetry;
2337 return rc;
2341 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2342 const char *fromName, const char *toName,
2343 const struct nls_table *nls_codepage, int remap)
2345 int rc = 0;
2346 NT_RENAME_REQ *pSMB = NULL;
2347 RENAME_RSP *pSMBr = NULL;
2348 int bytes_returned;
2349 int name_len, name_len2;
2350 __u16 count;
2352 cFYI(1, ("In CIFSCreateHardLink"));
2353 winCreateHardLinkRetry:
2355 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2356 (void **) &pSMBr);
2357 if (rc)
2358 return rc;
2360 pSMB->SearchAttributes =
2361 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2362 ATTR_DIRECTORY);
2363 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2364 pSMB->ClusterCount = 0;
2366 pSMB->BufferFormat = 0x04;
2368 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2369 name_len =
2370 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
2371 PATH_MAX, nls_codepage, remap);
2372 name_len++; /* trailing null */
2373 name_len *= 2;
2374 pSMB->OldFileName[name_len] = 0; /* pad */
2375 pSMB->OldFileName[name_len + 1] = 0x04;
2376 name_len2 =
2377 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2378 toName, PATH_MAX, nls_codepage, remap);
2379 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2380 name_len2 *= 2; /* convert to bytes */
2381 } else { /* BB improve the check for buffer overruns BB */
2382 name_len = strnlen(fromName, PATH_MAX);
2383 name_len++; /* trailing null */
2384 strncpy(pSMB->OldFileName, fromName, name_len);
2385 name_len2 = strnlen(toName, PATH_MAX);
2386 name_len2++; /* trailing null */
2387 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2388 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2389 name_len2++; /* trailing null */
2390 name_len2++; /* signature byte */
2393 count = 1 /* string type byte */ + name_len + name_len2;
2394 pSMB->hdr.smb_buf_length += count;
2395 pSMB->ByteCount = cpu_to_le16(count);
2397 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2398 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2399 cifs_stats_inc(&tcon->num_hardlinks);
2400 if (rc)
2401 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
2403 cifs_buf_release(pSMB);
2404 if (rc == -EAGAIN)
2405 goto winCreateHardLinkRetry;
2407 return rc;
2411 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
2412 const unsigned char *searchName,
2413 char *symlinkinfo, const int buflen,
2414 const struct nls_table *nls_codepage)
2416 /* SMB_QUERY_FILE_UNIX_LINK */
2417 TRANSACTION2_QPI_REQ *pSMB = NULL;
2418 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2419 int rc = 0;
2420 int bytes_returned;
2421 int name_len;
2422 __u16 params, byte_count;
2424 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
2426 querySymLinkRetry:
2427 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2428 (void **) &pSMBr);
2429 if (rc)
2430 return rc;
2432 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2433 name_len =
2434 cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
2435 PATH_MAX, nls_codepage);
2436 name_len++; /* trailing null */
2437 name_len *= 2;
2438 } else { /* BB improve the check for buffer overruns BB */
2439 name_len = strnlen(searchName, PATH_MAX);
2440 name_len++; /* trailing null */
2441 strncpy(pSMB->FileName, searchName, name_len);
2444 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2445 pSMB->TotalDataCount = 0;
2446 pSMB->MaxParameterCount = cpu_to_le16(2);
2447 /* BB find exact max data count below from sess structure BB */
2448 pSMB->MaxDataCount = cpu_to_le16(4000);
2449 pSMB->MaxSetupCount = 0;
2450 pSMB->Reserved = 0;
2451 pSMB->Flags = 0;
2452 pSMB->Timeout = 0;
2453 pSMB->Reserved2 = 0;
2454 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2455 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2456 pSMB->DataCount = 0;
2457 pSMB->DataOffset = 0;
2458 pSMB->SetupCount = 1;
2459 pSMB->Reserved3 = 0;
2460 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2461 byte_count = params + 1 /* pad */ ;
2462 pSMB->TotalParameterCount = cpu_to_le16(params);
2463 pSMB->ParameterCount = pSMB->TotalParameterCount;
2464 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2465 pSMB->Reserved4 = 0;
2466 pSMB->hdr.smb_buf_length += byte_count;
2467 pSMB->ByteCount = cpu_to_le16(byte_count);
2469 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2470 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2471 if (rc) {
2472 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
2473 } else {
2474 /* decode response */
2476 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2477 if (rc || (pSMBr->ByteCount < 2))
2478 /* BB also check enough total bytes returned */
2479 rc = -EIO; /* bad smb */
2480 else {
2481 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2482 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2484 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2485 name_len = UniStrnlen((wchar_t *) ((char *)
2486 &pSMBr->hdr.Protocol + data_offset),
2487 min_t(const int, buflen, count) / 2);
2488 /* BB FIXME investigate remapping reserved chars here */
2489 cifs_strfromUCS_le(symlinkinfo,
2490 (__le16 *) ((char *)&pSMBr->hdr.Protocol
2491 + data_offset),
2492 name_len, nls_codepage);
2493 } else {
2494 strncpy(symlinkinfo,
2495 (char *) &pSMBr->hdr.Protocol +
2496 data_offset,
2497 min_t(const int, buflen, count));
2499 symlinkinfo[buflen] = 0;
2500 /* just in case so calling code does not go off the end of buffer */
2503 cifs_buf_release(pSMB);
2504 if (rc == -EAGAIN)
2505 goto querySymLinkRetry;
2506 return rc;
2509 #ifdef CONFIG_CIFS_EXPERIMENTAL
2510 /* Initialize NT TRANSACT SMB into small smb request buffer.
2511 This assumes that all NT TRANSACTS that we init here have
2512 total parm and data under about 400 bytes (to fit in small cifs
2513 buffer size), which is the case so far, it easily fits. NB:
2514 Setup words themselves and ByteCount
2515 MaxSetupCount (size of returned setup area) and
2516 MaxParameterCount (returned parms size) must be set by caller */
2517 static int
2518 smb_init_nttransact(const __u16 sub_command, const int setup_count,
2519 const int parm_len, struct cifsTconInfo *tcon,
2520 void **ret_buf)
2522 int rc;
2523 __u32 temp_offset;
2524 struct smb_com_ntransact_req *pSMB;
2526 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
2527 (void **)&pSMB);
2528 if (rc)
2529 return rc;
2530 *ret_buf = (void *)pSMB;
2531 pSMB->Reserved = 0;
2532 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
2533 pSMB->TotalDataCount = 0;
2534 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2535 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2536 pSMB->ParameterCount = pSMB->TotalParameterCount;
2537 pSMB->DataCount = pSMB->TotalDataCount;
2538 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
2539 (setup_count * 2) - 4 /* for rfc1001 length itself */;
2540 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
2541 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
2542 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
2543 pSMB->SubCommand = cpu_to_le16(sub_command);
2544 return 0;
2547 static int
2548 validate_ntransact(char *buf, char **ppparm, char **ppdata,
2549 __u32 *pparmlen, __u32 *pdatalen)
2551 char *end_of_smb;
2552 __u32 data_count, data_offset, parm_count, parm_offset;
2553 struct smb_com_ntransact_rsp *pSMBr;
2555 *pdatalen = 0;
2556 *pparmlen = 0;
2558 if (buf == NULL)
2559 return -EINVAL;
2561 pSMBr = (struct smb_com_ntransact_rsp *)buf;
2563 /* ByteCount was converted from little endian in SendReceive */
2564 end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2565 (char *)&pSMBr->ByteCount;
2567 data_offset = le32_to_cpu(pSMBr->DataOffset);
2568 data_count = le32_to_cpu(pSMBr->DataCount);
2569 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2570 parm_count = le32_to_cpu(pSMBr->ParameterCount);
2572 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2573 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2575 /* should we also check that parm and data areas do not overlap? */
2576 if (*ppparm > end_of_smb) {
2577 cFYI(1, ("parms start after end of smb"));
2578 return -EINVAL;
2579 } else if (parm_count + *ppparm > end_of_smb) {
2580 cFYI(1, ("parm end after end of smb"));
2581 return -EINVAL;
2582 } else if (*ppdata > end_of_smb) {
2583 cFYI(1, ("data starts after end of smb"));
2584 return -EINVAL;
2585 } else if (data_count + *ppdata > end_of_smb) {
2586 cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
2587 *ppdata, data_count, (data_count + *ppdata),
2588 end_of_smb, pSMBr));
2589 return -EINVAL;
2590 } else if (parm_count + data_count > pSMBr->ByteCount) {
2591 cFYI(1, ("parm count and data count larger than SMB"));
2592 return -EINVAL;
2594 *pdatalen = data_count;
2595 *pparmlen = parm_count;
2596 return 0;
2598 #endif /* CIFS_EXPERIMENTAL */
2601 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
2602 const unsigned char *searchName,
2603 char *symlinkinfo, const int buflen, __u16 fid,
2604 const struct nls_table *nls_codepage)
2606 int rc = 0;
2607 int bytes_returned;
2608 int name_len;
2609 struct smb_com_transaction_ioctl_req *pSMB;
2610 struct smb_com_transaction_ioctl_rsp *pSMBr;
2612 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
2613 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2614 (void **) &pSMBr);
2615 if (rc)
2616 return rc;
2618 pSMB->TotalParameterCount = 0 ;
2619 pSMB->TotalDataCount = 0;
2620 pSMB->MaxParameterCount = cpu_to_le32(2);
2621 /* BB find exact data count max from sess structure BB */
2622 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2623 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2624 pSMB->MaxSetupCount = 4;
2625 pSMB->Reserved = 0;
2626 pSMB->ParameterOffset = 0;
2627 pSMB->DataCount = 0;
2628 pSMB->DataOffset = 0;
2629 pSMB->SetupCount = 4;
2630 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2631 pSMB->ParameterCount = pSMB->TotalParameterCount;
2632 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2633 pSMB->IsFsctl = 1; /* FSCTL */
2634 pSMB->IsRootFlag = 0;
2635 pSMB->Fid = fid; /* file handle always le */
2636 pSMB->ByteCount = 0;
2638 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2639 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2640 if (rc) {
2641 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
2642 } else { /* decode response */
2643 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
2644 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
2645 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
2646 /* BB also check enough total bytes returned */
2647 rc = -EIO; /* bad smb */
2648 else {
2649 if (data_count && (data_count < 2048)) {
2650 char *end_of_smb = 2 /* sizeof byte count */ +
2651 pSMBr->ByteCount +
2652 (char *)&pSMBr->ByteCount;
2654 struct reparse_data *reparse_buf =
2655 (struct reparse_data *)
2656 ((char *)&pSMBr->hdr.Protocol
2657 + data_offset);
2658 if ((char *)reparse_buf >= end_of_smb) {
2659 rc = -EIO;
2660 goto qreparse_out;
2662 if ((reparse_buf->LinkNamesBuf +
2663 reparse_buf->TargetNameOffset +
2664 reparse_buf->TargetNameLen) >
2665 end_of_smb) {
2666 cFYI(1, ("reparse buf beyond SMB"));
2667 rc = -EIO;
2668 goto qreparse_out;
2671 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2672 name_len = UniStrnlen((wchar_t *)
2673 (reparse_buf->LinkNamesBuf +
2674 reparse_buf->TargetNameOffset),
2675 min(buflen/2,
2676 reparse_buf->TargetNameLen / 2));
2677 cifs_strfromUCS_le(symlinkinfo,
2678 (__le16 *) (reparse_buf->LinkNamesBuf +
2679 reparse_buf->TargetNameOffset),
2680 name_len, nls_codepage);
2681 } else { /* ASCII names */
2682 strncpy(symlinkinfo,
2683 reparse_buf->LinkNamesBuf +
2684 reparse_buf->TargetNameOffset,
2685 min_t(const int, buflen,
2686 reparse_buf->TargetNameLen));
2688 } else {
2689 rc = -EIO;
2690 cFYI(1, ("Invalid return data count on "
2691 "get reparse info ioctl"));
2693 symlinkinfo[buflen] = 0; /* just in case so the caller
2694 does not go off the end of the buffer */
2695 cFYI(1, ("readlink result - %s", symlinkinfo));
2698 qreparse_out:
2699 cifs_buf_release(pSMB);
2701 /* Note: On -EAGAIN error only caller can retry on handle based calls
2702 since file handle passed in no longer valid */
2704 return rc;
2707 #ifdef CONFIG_CIFS_POSIX
2709 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
2710 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
2711 struct cifs_posix_ace *cifs_ace)
2713 /* u8 cifs fields do not need le conversion */
2714 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
2715 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
2716 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
2717 /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
2719 return;
2722 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
2723 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
2724 const int acl_type, const int size_of_data_area)
2726 int size = 0;
2727 int i;
2728 __u16 count;
2729 struct cifs_posix_ace *pACE;
2730 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
2731 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
2733 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2734 return -EOPNOTSUPP;
2736 if (acl_type & ACL_TYPE_ACCESS) {
2737 count = le16_to_cpu(cifs_acl->access_entry_count);
2738 pACE = &cifs_acl->ace_array[0];
2739 size = sizeof(struct cifs_posix_acl);
2740 size += sizeof(struct cifs_posix_ace) * count;
2741 /* check if we would go beyond end of SMB */
2742 if (size_of_data_area < size) {
2743 cFYI(1, ("bad CIFS POSIX ACL size %d vs. %d",
2744 size_of_data_area, size));
2745 return -EINVAL;
2747 } else if (acl_type & ACL_TYPE_DEFAULT) {
2748 count = le16_to_cpu(cifs_acl->access_entry_count);
2749 size = sizeof(struct cifs_posix_acl);
2750 size += sizeof(struct cifs_posix_ace) * count;
2751 /* skip past access ACEs to get to default ACEs */
2752 pACE = &cifs_acl->ace_array[count];
2753 count = le16_to_cpu(cifs_acl->default_entry_count);
2754 size += sizeof(struct cifs_posix_ace) * count;
2755 /* check if we would go beyond end of SMB */
2756 if (size_of_data_area < size)
2757 return -EINVAL;
2758 } else {
2759 /* illegal type */
2760 return -EINVAL;
2763 size = posix_acl_xattr_size(count);
2764 if ((buflen == 0) || (local_acl == NULL)) {
2765 /* used to query ACL EA size */
2766 } else if (size > buflen) {
2767 return -ERANGE;
2768 } else /* buffer big enough */ {
2769 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
2770 for (i = 0; i < count ; i++) {
2771 cifs_convert_ace(&local_acl->a_entries[i], pACE);
2772 pACE++;
2775 return size;
2778 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
2779 const posix_acl_xattr_entry *local_ace)
2781 __u16 rc = 0; /* 0 = ACL converted ok */
2783 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
2784 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
2785 /* BB is there a better way to handle the large uid? */
2786 if (local_ace->e_id == cpu_to_le32(-1)) {
2787 /* Probably no need to le convert -1 on any arch but can not hurt */
2788 cifs_ace->cifs_uid = cpu_to_le64(-1);
2789 } else
2790 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
2791 /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
2792 return rc;
2795 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
2796 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
2797 const int buflen, const int acl_type)
2799 __u16 rc = 0;
2800 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
2801 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
2802 int count;
2803 int i;
2805 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
2806 return 0;
2808 count = posix_acl_xattr_count((size_t)buflen);
2809 cFYI(1, ("setting acl with %d entries from buf of length %d and "
2810 "version of %d",
2811 count, buflen, le32_to_cpu(local_acl->a_version)));
2812 if (le32_to_cpu(local_acl->a_version) != 2) {
2813 cFYI(1, ("unknown POSIX ACL version %d",
2814 le32_to_cpu(local_acl->a_version)));
2815 return 0;
2817 cifs_acl->version = cpu_to_le16(1);
2818 if (acl_type == ACL_TYPE_ACCESS)
2819 cifs_acl->access_entry_count = cpu_to_le16(count);
2820 else if (acl_type == ACL_TYPE_DEFAULT)
2821 cifs_acl->default_entry_count = cpu_to_le16(count);
2822 else {
2823 cFYI(1, ("unknown ACL type %d", acl_type));
2824 return 0;
2826 for (i = 0; i < count; i++) {
2827 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
2828 &local_acl->a_entries[i]);
2829 if (rc != 0) {
2830 /* ACE not converted */
2831 break;
2834 if (rc == 0) {
2835 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
2836 rc += sizeof(struct cifs_posix_acl);
2837 /* BB add check to make sure ACL does not overflow SMB */
2839 return rc;
2843 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
2844 const unsigned char *searchName,
2845 char *acl_inf, const int buflen, const int acl_type,
2846 const struct nls_table *nls_codepage, int remap)
2848 /* SMB_QUERY_POSIX_ACL */
2849 TRANSACTION2_QPI_REQ *pSMB = NULL;
2850 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2851 int rc = 0;
2852 int bytes_returned;
2853 int name_len;
2854 __u16 params, byte_count;
2856 cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
2858 queryAclRetry:
2859 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2860 (void **) &pSMBr);
2861 if (rc)
2862 return rc;
2864 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2865 name_len =
2866 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2867 PATH_MAX, nls_codepage, remap);
2868 name_len++; /* trailing null */
2869 name_len *= 2;
2870 pSMB->FileName[name_len] = 0;
2871 pSMB->FileName[name_len+1] = 0;
2872 } else { /* BB improve the check for buffer overruns BB */
2873 name_len = strnlen(searchName, PATH_MAX);
2874 name_len++; /* trailing null */
2875 strncpy(pSMB->FileName, searchName, name_len);
2878 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2879 pSMB->TotalDataCount = 0;
2880 pSMB->MaxParameterCount = cpu_to_le16(2);
2881 /* BB find exact max data count below from sess structure BB */
2882 pSMB->MaxDataCount = cpu_to_le16(4000);
2883 pSMB->MaxSetupCount = 0;
2884 pSMB->Reserved = 0;
2885 pSMB->Flags = 0;
2886 pSMB->Timeout = 0;
2887 pSMB->Reserved2 = 0;
2888 pSMB->ParameterOffset = cpu_to_le16(
2889 offsetof(struct smb_com_transaction2_qpi_req,
2890 InformationLevel) - 4);
2891 pSMB->DataCount = 0;
2892 pSMB->DataOffset = 0;
2893 pSMB->SetupCount = 1;
2894 pSMB->Reserved3 = 0;
2895 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2896 byte_count = params + 1 /* pad */ ;
2897 pSMB->TotalParameterCount = cpu_to_le16(params);
2898 pSMB->ParameterCount = pSMB->TotalParameterCount;
2899 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
2900 pSMB->Reserved4 = 0;
2901 pSMB->hdr.smb_buf_length += byte_count;
2902 pSMB->ByteCount = cpu_to_le16(byte_count);
2904 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2905 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2906 cifs_stats_inc(&tcon->num_acl_get);
2907 if (rc) {
2908 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
2909 } else {
2910 /* decode response */
2912 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2913 if (rc || (pSMBr->ByteCount < 2))
2914 /* BB also check enough total bytes returned */
2915 rc = -EIO; /* bad smb */
2916 else {
2917 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2918 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2919 rc = cifs_copy_posix_acl(acl_inf,
2920 (char *)&pSMBr->hdr.Protocol+data_offset,
2921 buflen, acl_type, count);
2924 cifs_buf_release(pSMB);
2925 if (rc == -EAGAIN)
2926 goto queryAclRetry;
2927 return rc;
2931 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2932 const unsigned char *fileName,
2933 const char *local_acl, const int buflen,
2934 const int acl_type,
2935 const struct nls_table *nls_codepage, int remap)
2937 struct smb_com_transaction2_spi_req *pSMB = NULL;
2938 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2939 char *parm_data;
2940 int name_len;
2941 int rc = 0;
2942 int bytes_returned = 0;
2943 __u16 params, byte_count, data_count, param_offset, offset;
2945 cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2946 setAclRetry:
2947 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2948 (void **) &pSMBr);
2949 if (rc)
2950 return rc;
2951 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2952 name_len =
2953 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2954 PATH_MAX, nls_codepage, remap);
2955 name_len++; /* trailing null */
2956 name_len *= 2;
2957 } else { /* BB improve the check for buffer overruns BB */
2958 name_len = strnlen(fileName, PATH_MAX);
2959 name_len++; /* trailing null */
2960 strncpy(pSMB->FileName, fileName, name_len);
2962 params = 6 + name_len;
2963 pSMB->MaxParameterCount = cpu_to_le16(2);
2964 /* BB find max SMB size from sess */
2965 pSMB->MaxDataCount = cpu_to_le16(1000);
2966 pSMB->MaxSetupCount = 0;
2967 pSMB->Reserved = 0;
2968 pSMB->Flags = 0;
2969 pSMB->Timeout = 0;
2970 pSMB->Reserved2 = 0;
2971 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2972 InformationLevel) - 4;
2973 offset = param_offset + params;
2974 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2975 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2977 /* convert to on the wire format for POSIX ACL */
2978 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
2980 if (data_count == 0) {
2981 rc = -EOPNOTSUPP;
2982 goto setACLerrorExit;
2984 pSMB->DataOffset = cpu_to_le16(offset);
2985 pSMB->SetupCount = 1;
2986 pSMB->Reserved3 = 0;
2987 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2988 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2989 byte_count = 3 /* pad */ + params + data_count;
2990 pSMB->DataCount = cpu_to_le16(data_count);
2991 pSMB->TotalDataCount = pSMB->DataCount;
2992 pSMB->ParameterCount = cpu_to_le16(params);
2993 pSMB->TotalParameterCount = pSMB->ParameterCount;
2994 pSMB->Reserved4 = 0;
2995 pSMB->hdr.smb_buf_length += byte_count;
2996 pSMB->ByteCount = cpu_to_le16(byte_count);
2997 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2998 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2999 if (rc)
3000 cFYI(1, ("Set POSIX ACL returned %d", rc));
3002 setACLerrorExit:
3003 cifs_buf_release(pSMB);
3004 if (rc == -EAGAIN)
3005 goto setAclRetry;
3006 return rc;
3009 /* BB fix tabs in this function FIXME BB */
3011 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
3012 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3014 int rc = 0;
3015 struct smb_t2_qfi_req *pSMB = NULL;
3016 struct smb_t2_qfi_rsp *pSMBr = NULL;
3017 int bytes_returned;
3018 __u16 params, byte_count;
3020 cFYI(1, ("In GetExtAttr"));
3021 if (tcon == NULL)
3022 return -ENODEV;
3024 GetExtAttrRetry:
3025 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3026 (void **) &pSMBr);
3027 if (rc)
3028 return rc;
3030 params = 2 /* level */ + 2 /* fid */;
3031 pSMB->t2.TotalDataCount = 0;
3032 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3033 /* BB find exact max data count below from sess structure BB */
3034 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3035 pSMB->t2.MaxSetupCount = 0;
3036 pSMB->t2.Reserved = 0;
3037 pSMB->t2.Flags = 0;
3038 pSMB->t2.Timeout = 0;
3039 pSMB->t2.Reserved2 = 0;
3040 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3041 Fid) - 4);
3042 pSMB->t2.DataCount = 0;
3043 pSMB->t2.DataOffset = 0;
3044 pSMB->t2.SetupCount = 1;
3045 pSMB->t2.Reserved3 = 0;
3046 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3047 byte_count = params + 1 /* pad */ ;
3048 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3049 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3050 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3051 pSMB->Pad = 0;
3052 pSMB->Fid = netfid;
3053 pSMB->hdr.smb_buf_length += byte_count;
3054 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3056 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3057 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3058 if (rc) {
3059 cFYI(1, ("error %d in GetExtAttr", rc));
3060 } else {
3061 /* decode response */
3062 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3063 if (rc || (pSMBr->ByteCount < 2))
3064 /* BB also check enough total bytes returned */
3065 /* If rc should we check for EOPNOSUPP and
3066 disable the srvino flag? or in caller? */
3067 rc = -EIO; /* bad smb */
3068 else {
3069 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3070 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3071 struct file_chattr_info *pfinfo;
3072 /* BB Do we need a cast or hash here ? */
3073 if (count != 16) {
3074 cFYI(1, ("Illegal size ret in GetExtAttr"));
3075 rc = -EIO;
3076 goto GetExtAttrOut;
3078 pfinfo = (struct file_chattr_info *)
3079 (data_offset + (char *) &pSMBr->hdr.Protocol);
3080 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3081 *pMask = le64_to_cpu(pfinfo->mask);
3084 GetExtAttrOut:
3085 cifs_buf_release(pSMB);
3086 if (rc == -EAGAIN)
3087 goto GetExtAttrRetry;
3088 return rc;
3091 #endif /* CONFIG_POSIX */
3093 #ifdef CONFIG_CIFS_EXPERIMENTAL
3094 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3096 CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3097 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3099 int rc = 0;
3100 int buf_type = 0;
3101 QUERY_SEC_DESC_REQ *pSMB;
3102 struct kvec iov[1];
3104 cFYI(1, ("GetCifsACL"));
3106 *pbuflen = 0;
3107 *acl_inf = NULL;
3109 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3110 8 /* parm len */, tcon, (void **) &pSMB);
3111 if (rc)
3112 return rc;
3114 pSMB->MaxParameterCount = cpu_to_le32(4);
3115 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3116 pSMB->MaxSetupCount = 0;
3117 pSMB->Fid = fid; /* file handle always le */
3118 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3119 CIFS_ACL_DACL);
3120 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3121 pSMB->hdr.smb_buf_length += 11;
3122 iov[0].iov_base = (char *)pSMB;
3123 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
3125 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3126 CIFS_STD_OP);
3127 cifs_stats_inc(&tcon->num_acl_get);
3128 if (rc) {
3129 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
3130 } else { /* decode response */
3131 __le32 *parm;
3132 __u32 parm_len;
3133 __u32 acl_len;
3134 struct smb_com_ntransact_rsp *pSMBr;
3135 char *pdata;
3137 /* validate_nttransact */
3138 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3139 &pdata, &parm_len, pbuflen);
3140 if (rc)
3141 goto qsec_out;
3142 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3144 cFYI(1, ("smb %p parm %p data %p", pSMBr, parm, *acl_inf));
3146 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3147 rc = -EIO; /* bad smb */
3148 *pbuflen = 0;
3149 goto qsec_out;
3152 /* BB check that data area is minimum length and as big as acl_len */
3154 acl_len = le32_to_cpu(*parm);
3155 if (acl_len != *pbuflen) {
3156 cERROR(1, ("acl length %d does not match %d",
3157 acl_len, *pbuflen));
3158 if (*pbuflen > acl_len)
3159 *pbuflen = acl_len;
3162 /* check if buffer is big enough for the acl
3163 header followed by the smallest SID */
3164 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3165 (*pbuflen >= 64 * 1024)) {
3166 cERROR(1, ("bad acl length %d", *pbuflen));
3167 rc = -EINVAL;
3168 *pbuflen = 0;
3169 } else {
3170 *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3171 if (*acl_inf == NULL) {
3172 *pbuflen = 0;
3173 rc = -ENOMEM;
3175 memcpy(*acl_inf, pdata, *pbuflen);
3178 qsec_out:
3179 if (buf_type == CIFS_SMALL_BUFFER)
3180 cifs_small_buf_release(iov[0].iov_base);
3181 else if (buf_type == CIFS_LARGE_BUFFER)
3182 cifs_buf_release(iov[0].iov_base);
3183 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3184 return rc;
3188 CIFSSMBSetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3189 struct cifs_ntsd *pntsd, __u32 acllen)
3191 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3192 int rc = 0;
3193 int bytes_returned = 0;
3194 SET_SEC_DESC_REQ *pSMB = NULL;
3195 NTRANSACT_RSP *pSMBr = NULL;
3197 setCifsAclRetry:
3198 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3199 (void **) &pSMBr);
3200 if (rc)
3201 return (rc);
3203 pSMB->MaxSetupCount = 0;
3204 pSMB->Reserved = 0;
3206 param_count = 8;
3207 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3208 data_count = acllen;
3209 data_offset = param_offset + param_count;
3210 byte_count = 3 /* pad */ + param_count;
3212 pSMB->DataCount = cpu_to_le32(data_count);
3213 pSMB->TotalDataCount = pSMB->DataCount;
3214 pSMB->MaxParameterCount = cpu_to_le32(4);
3215 pSMB->MaxDataCount = cpu_to_le32(16384);
3216 pSMB->ParameterCount = cpu_to_le32(param_count);
3217 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3218 pSMB->TotalParameterCount = pSMB->ParameterCount;
3219 pSMB->DataOffset = cpu_to_le32(data_offset);
3220 pSMB->SetupCount = 0;
3221 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3222 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3224 pSMB->Fid = fid; /* file handle always le */
3225 pSMB->Reserved2 = 0;
3226 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_DACL);
3228 if (pntsd && acllen) {
3229 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3230 (char *) pntsd,
3231 acllen);
3232 pSMB->hdr.smb_buf_length += (byte_count + data_count);
3234 } else
3235 pSMB->hdr.smb_buf_length += byte_count;
3237 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3238 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3240 cFYI(1, ("SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc));
3241 if (rc)
3242 cFYI(1, ("Set CIFS ACL returned %d", rc));
3243 cifs_buf_release(pSMB);
3245 if (rc == -EAGAIN)
3246 goto setCifsAclRetry;
3248 return (rc);
3251 #endif /* CONFIG_CIFS_EXPERIMENTAL */
3253 /* Legacy Query Path Information call for lookup to old servers such
3254 as Win9x/WinME */
3255 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
3256 const unsigned char *searchName,
3257 FILE_ALL_INFO *pFinfo,
3258 const struct nls_table *nls_codepage, int remap)
3260 QUERY_INFORMATION_REQ *pSMB;
3261 QUERY_INFORMATION_RSP *pSMBr;
3262 int rc = 0;
3263 int bytes_returned;
3264 int name_len;
3266 cFYI(1, ("In SMBQPath path %s", searchName));
3267 QInfRetry:
3268 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3269 (void **) &pSMBr);
3270 if (rc)
3271 return rc;
3273 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3274 name_len =
3275 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3276 PATH_MAX, nls_codepage, remap);
3277 name_len++; /* trailing null */
3278 name_len *= 2;
3279 } else {
3280 name_len = strnlen(searchName, PATH_MAX);
3281 name_len++; /* trailing null */
3282 strncpy(pSMB->FileName, searchName, name_len);
3284 pSMB->BufferFormat = 0x04;
3285 name_len++; /* account for buffer type byte */
3286 pSMB->hdr.smb_buf_length += (__u16) name_len;
3287 pSMB->ByteCount = cpu_to_le16(name_len);
3289 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3290 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3291 if (rc) {
3292 cFYI(1, ("Send error in QueryInfo = %d", rc));
3293 } else if (pFinfo) {
3294 struct timespec ts;
3295 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3297 /* decode response */
3298 /* BB FIXME - add time zone adjustment BB */
3299 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
3300 ts.tv_nsec = 0;
3301 ts.tv_sec = time;
3302 /* decode time fields */
3303 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3304 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3305 pFinfo->LastAccessTime = 0;
3306 pFinfo->AllocationSize =
3307 cpu_to_le64(le32_to_cpu(pSMBr->size));
3308 pFinfo->EndOfFile = pFinfo->AllocationSize;
3309 pFinfo->Attributes =
3310 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3311 } else
3312 rc = -EIO; /* bad buffer passed in */
3314 cifs_buf_release(pSMB);
3316 if (rc == -EAGAIN)
3317 goto QInfRetry;
3319 return rc;
3326 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
3327 const unsigned char *searchName,
3328 FILE_ALL_INFO *pFindData,
3329 int legacy /* old style infolevel */,
3330 const struct nls_table *nls_codepage, int remap)
3332 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3333 TRANSACTION2_QPI_REQ *pSMB = NULL;
3334 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3335 int rc = 0;
3336 int bytes_returned;
3337 int name_len;
3338 __u16 params, byte_count;
3340 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
3341 QPathInfoRetry:
3342 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3343 (void **) &pSMBr);
3344 if (rc)
3345 return rc;
3347 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3348 name_len =
3349 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3350 PATH_MAX, nls_codepage, remap);
3351 name_len++; /* trailing null */
3352 name_len *= 2;
3353 } else { /* BB improve the check for buffer overruns BB */
3354 name_len = strnlen(searchName, PATH_MAX);
3355 name_len++; /* trailing null */
3356 strncpy(pSMB->FileName, searchName, name_len);
3359 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3360 pSMB->TotalDataCount = 0;
3361 pSMB->MaxParameterCount = cpu_to_le16(2);
3362 /* BB find exact max SMB PDU from sess structure BB */
3363 pSMB->MaxDataCount = cpu_to_le16(4000);
3364 pSMB->MaxSetupCount = 0;
3365 pSMB->Reserved = 0;
3366 pSMB->Flags = 0;
3367 pSMB->Timeout = 0;
3368 pSMB->Reserved2 = 0;
3369 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3370 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3371 pSMB->DataCount = 0;
3372 pSMB->DataOffset = 0;
3373 pSMB->SetupCount = 1;
3374 pSMB->Reserved3 = 0;
3375 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3376 byte_count = params + 1 /* pad */ ;
3377 pSMB->TotalParameterCount = cpu_to_le16(params);
3378 pSMB->ParameterCount = pSMB->TotalParameterCount;
3379 if (legacy)
3380 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3381 else
3382 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3383 pSMB->Reserved4 = 0;
3384 pSMB->hdr.smb_buf_length += byte_count;
3385 pSMB->ByteCount = cpu_to_le16(byte_count);
3387 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3388 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3389 if (rc) {
3390 cFYI(1, ("Send error in QPathInfo = %d", rc));
3391 } else { /* decode response */
3392 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3394 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3395 rc = -EIO;
3396 else if (!legacy && (pSMBr->ByteCount < 40))
3397 rc = -EIO; /* bad smb */
3398 else if (legacy && (pSMBr->ByteCount < 24))
3399 rc = -EIO; /* 24 or 26 expected but we do not read
3400 last field */
3401 else if (pFindData) {
3402 int size;
3403 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3405 /* On legacy responses we do not read the last field,
3406 EAsize, fortunately since it varies by subdialect and
3407 also note it differs on Set vs. Get, ie two bytes or 4
3408 bytes depending but we don't care here */
3409 if (legacy)
3410 size = sizeof(FILE_INFO_STANDARD);
3411 else
3412 size = sizeof(FILE_ALL_INFO);
3413 memcpy((char *) pFindData,
3414 (char *) &pSMBr->hdr.Protocol +
3415 data_offset, size);
3416 } else
3417 rc = -ENOMEM;
3419 cifs_buf_release(pSMB);
3420 if (rc == -EAGAIN)
3421 goto QPathInfoRetry;
3423 return rc;
3427 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
3428 const unsigned char *searchName,
3429 FILE_UNIX_BASIC_INFO *pFindData,
3430 const struct nls_table *nls_codepage, int remap)
3432 /* SMB_QUERY_FILE_UNIX_BASIC */
3433 TRANSACTION2_QPI_REQ *pSMB = NULL;
3434 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3435 int rc = 0;
3436 int bytes_returned = 0;
3437 int name_len;
3438 __u16 params, byte_count;
3440 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
3441 UnixQPathInfoRetry:
3442 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3443 (void **) &pSMBr);
3444 if (rc)
3445 return rc;
3447 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3448 name_len =
3449 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3450 PATH_MAX, nls_codepage, remap);
3451 name_len++; /* trailing null */
3452 name_len *= 2;
3453 } else { /* BB improve the check for buffer overruns BB */
3454 name_len = strnlen(searchName, PATH_MAX);
3455 name_len++; /* trailing null */
3456 strncpy(pSMB->FileName, searchName, name_len);
3459 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3460 pSMB->TotalDataCount = 0;
3461 pSMB->MaxParameterCount = cpu_to_le16(2);
3462 /* BB find exact max SMB PDU from sess structure BB */
3463 pSMB->MaxDataCount = cpu_to_le16(4000);
3464 pSMB->MaxSetupCount = 0;
3465 pSMB->Reserved = 0;
3466 pSMB->Flags = 0;
3467 pSMB->Timeout = 0;
3468 pSMB->Reserved2 = 0;
3469 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3470 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3471 pSMB->DataCount = 0;
3472 pSMB->DataOffset = 0;
3473 pSMB->SetupCount = 1;
3474 pSMB->Reserved3 = 0;
3475 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3476 byte_count = params + 1 /* pad */ ;
3477 pSMB->TotalParameterCount = cpu_to_le16(params);
3478 pSMB->ParameterCount = pSMB->TotalParameterCount;
3479 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3480 pSMB->Reserved4 = 0;
3481 pSMB->hdr.smb_buf_length += byte_count;
3482 pSMB->ByteCount = cpu_to_le16(byte_count);
3484 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3485 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3486 if (rc) {
3487 cFYI(1, ("Send error in QPathInfo = %d", rc));
3488 } else { /* decode response */
3489 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3491 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
3492 cERROR(1, ("Malformed FILE_UNIX_BASIC_INFO response.\n"
3493 "Unix Extensions can be disabled on mount "
3494 "by specifying the nosfu mount option."));
3495 rc = -EIO; /* bad smb */
3496 } else {
3497 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3498 memcpy((char *) pFindData,
3499 (char *) &pSMBr->hdr.Protocol +
3500 data_offset,
3501 sizeof(FILE_UNIX_BASIC_INFO));
3504 cifs_buf_release(pSMB);
3505 if (rc == -EAGAIN)
3506 goto UnixQPathInfoRetry;
3508 return rc;
3511 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3513 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
3514 const char *searchName,
3515 const struct nls_table *nls_codepage,
3516 __u16 *pnetfid,
3517 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
3519 /* level 257 SMB_ */
3520 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3521 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3522 T2_FFIRST_RSP_PARMS *parms;
3523 int rc = 0;
3524 int bytes_returned = 0;
3525 int name_len;
3526 __u16 params, byte_count;
3528 cFYI(1, ("In FindFirst for %s", searchName));
3530 findFirstRetry:
3531 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3532 (void **) &pSMBr);
3533 if (rc)
3534 return rc;
3536 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3537 name_len =
3538 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3539 PATH_MAX, nls_codepage, remap);
3540 /* We can not add the asterik earlier in case
3541 it got remapped to 0xF03A as if it were part of the
3542 directory name instead of a wildcard */
3543 name_len *= 2;
3544 pSMB->FileName[name_len] = dirsep;
3545 pSMB->FileName[name_len+1] = 0;
3546 pSMB->FileName[name_len+2] = '*';
3547 pSMB->FileName[name_len+3] = 0;
3548 name_len += 4; /* now the trailing null */
3549 pSMB->FileName[name_len] = 0; /* null terminate just in case */
3550 pSMB->FileName[name_len+1] = 0;
3551 name_len += 2;
3552 } else { /* BB add check for overrun of SMB buf BB */
3553 name_len = strnlen(searchName, PATH_MAX);
3554 /* BB fix here and in unicode clause above ie
3555 if (name_len > buffersize-header)
3556 free buffer exit; BB */
3557 strncpy(pSMB->FileName, searchName, name_len);
3558 pSMB->FileName[name_len] = dirsep;
3559 pSMB->FileName[name_len+1] = '*';
3560 pSMB->FileName[name_len+2] = 0;
3561 name_len += 3;
3564 params = 12 + name_len /* includes null */ ;
3565 pSMB->TotalDataCount = 0; /* no EAs */
3566 pSMB->MaxParameterCount = cpu_to_le16(10);
3567 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
3568 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3569 pSMB->MaxSetupCount = 0;
3570 pSMB->Reserved = 0;
3571 pSMB->Flags = 0;
3572 pSMB->Timeout = 0;
3573 pSMB->Reserved2 = 0;
3574 byte_count = params + 1 /* pad */ ;
3575 pSMB->TotalParameterCount = cpu_to_le16(params);
3576 pSMB->ParameterCount = pSMB->TotalParameterCount;
3577 pSMB->ParameterOffset = cpu_to_le16(
3578 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3579 - 4);
3580 pSMB->DataCount = 0;
3581 pSMB->DataOffset = 0;
3582 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
3583 pSMB->Reserved3 = 0;
3584 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3585 pSMB->SearchAttributes =
3586 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3587 ATTR_DIRECTORY);
3588 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3589 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
3590 CIFS_SEARCH_RETURN_RESUME);
3591 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3593 /* BB what should we set StorageType to? Does it matter? BB */
3594 pSMB->SearchStorageType = 0;
3595 pSMB->hdr.smb_buf_length += byte_count;
3596 pSMB->ByteCount = cpu_to_le16(byte_count);
3598 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3599 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3600 cifs_stats_inc(&tcon->num_ffirst);
3602 if (rc) {/* BB add logic to retry regular search if Unix search
3603 rejected unexpectedly by server */
3604 /* BB Add code to handle unsupported level rc */
3605 cFYI(1, ("Error in FindFirst = %d", rc));
3607 cifs_buf_release(pSMB);
3609 /* BB eventually could optimize out free and realloc of buf */
3610 /* for this case */
3611 if (rc == -EAGAIN)
3612 goto findFirstRetry;
3613 } else { /* decode response */
3614 /* BB remember to free buffer if error BB */
3615 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3616 if (rc == 0) {
3617 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3618 psrch_inf->unicode = true;
3619 else
3620 psrch_inf->unicode = false;
3622 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3623 psrch_inf->smallBuf = 0;
3624 psrch_inf->srch_entries_start =
3625 (char *) &pSMBr->hdr.Protocol +
3626 le16_to_cpu(pSMBr->t2.DataOffset);
3627 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3628 le16_to_cpu(pSMBr->t2.ParameterOffset));
3630 if (parms->EndofSearch)
3631 psrch_inf->endOfSearch = true;
3632 else
3633 psrch_inf->endOfSearch = false;
3635 psrch_inf->entries_in_buffer =
3636 le16_to_cpu(parms->SearchCount);
3637 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
3638 psrch_inf->entries_in_buffer;
3639 *pnetfid = parms->SearchHandle;
3640 } else {
3641 cifs_buf_release(pSMB);
3645 return rc;
3648 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3649 __u16 searchHandle, struct cifs_search_info *psrch_inf)
3651 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3652 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3653 T2_FNEXT_RSP_PARMS *parms;
3654 char *response_data;
3655 int rc = 0;
3656 int bytes_returned, name_len;
3657 __u16 params, byte_count;
3659 cFYI(1, ("In FindNext"));
3661 if (psrch_inf->endOfSearch)
3662 return -ENOENT;
3664 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3665 (void **) &pSMBr);
3666 if (rc)
3667 return rc;
3669 params = 14; /* includes 2 bytes of null string, converted to LE below*/
3670 byte_count = 0;
3671 pSMB->TotalDataCount = 0; /* no EAs */
3672 pSMB->MaxParameterCount = cpu_to_le16(8);
3673 pSMB->MaxDataCount =
3674 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
3675 0xFFFFFF00);
3676 pSMB->MaxSetupCount = 0;
3677 pSMB->Reserved = 0;
3678 pSMB->Flags = 0;
3679 pSMB->Timeout = 0;
3680 pSMB->Reserved2 = 0;
3681 pSMB->ParameterOffset = cpu_to_le16(
3682 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3683 pSMB->DataCount = 0;
3684 pSMB->DataOffset = 0;
3685 pSMB->SetupCount = 1;
3686 pSMB->Reserved3 = 0;
3687 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3688 pSMB->SearchHandle = searchHandle; /* always kept as le */
3689 pSMB->SearchCount =
3690 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
3691 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3692 pSMB->ResumeKey = psrch_inf->resume_key;
3693 pSMB->SearchFlags =
3694 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3696 name_len = psrch_inf->resume_name_len;
3697 params += name_len;
3698 if (name_len < PATH_MAX) {
3699 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3700 byte_count += name_len;
3701 /* 14 byte parm len above enough for 2 byte null terminator */
3702 pSMB->ResumeFileName[name_len] = 0;
3703 pSMB->ResumeFileName[name_len+1] = 0;
3704 } else {
3705 rc = -EINVAL;
3706 goto FNext2_err_exit;
3708 byte_count = params + 1 /* pad */ ;
3709 pSMB->TotalParameterCount = cpu_to_le16(params);
3710 pSMB->ParameterCount = pSMB->TotalParameterCount;
3711 pSMB->hdr.smb_buf_length += byte_count;
3712 pSMB->ByteCount = cpu_to_le16(byte_count);
3714 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3715 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3716 cifs_stats_inc(&tcon->num_fnext);
3717 if (rc) {
3718 if (rc == -EBADF) {
3719 psrch_inf->endOfSearch = true;
3720 cifs_buf_release(pSMB);
3721 rc = 0; /* search probably was closed at end of search*/
3722 } else
3723 cFYI(1, ("FindNext returned = %d", rc));
3724 } else { /* decode response */
3725 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3727 if (rc == 0) {
3728 /* BB fixme add lock for file (srch_info) struct here */
3729 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3730 psrch_inf->unicode = true;
3731 else
3732 psrch_inf->unicode = false;
3733 response_data = (char *) &pSMBr->hdr.Protocol +
3734 le16_to_cpu(pSMBr->t2.ParameterOffset);
3735 parms = (T2_FNEXT_RSP_PARMS *)response_data;
3736 response_data = (char *)&pSMBr->hdr.Protocol +
3737 le16_to_cpu(pSMBr->t2.DataOffset);
3738 if (psrch_inf->smallBuf)
3739 cifs_small_buf_release(
3740 psrch_inf->ntwrk_buf_start);
3741 else
3742 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3743 psrch_inf->srch_entries_start = response_data;
3744 psrch_inf->ntwrk_buf_start = (char *)pSMB;
3745 psrch_inf->smallBuf = 0;
3746 if (parms->EndofSearch)
3747 psrch_inf->endOfSearch = true;
3748 else
3749 psrch_inf->endOfSearch = false;
3750 psrch_inf->entries_in_buffer =
3751 le16_to_cpu(parms->SearchCount);
3752 psrch_inf->index_of_last_entry +=
3753 psrch_inf->entries_in_buffer;
3754 /* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",
3755 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry)); */
3757 /* BB fixme add unlock here */
3762 /* BB On error, should we leave previous search buf (and count and
3763 last entry fields) intact or free the previous one? */
3765 /* Note: On -EAGAIN error only caller can retry on handle based calls
3766 since file handle passed in no longer valid */
3767 FNext2_err_exit:
3768 if (rc != 0)
3769 cifs_buf_release(pSMB);
3770 return rc;
3774 CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
3775 const __u16 searchHandle)
3777 int rc = 0;
3778 FINDCLOSE_REQ *pSMB = NULL;
3780 cFYI(1, ("In CIFSSMBFindClose"));
3781 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3783 /* no sense returning error if session restarted
3784 as file handle has been closed */
3785 if (rc == -EAGAIN)
3786 return 0;
3787 if (rc)
3788 return rc;
3790 pSMB->FileID = searchHandle;
3791 pSMB->ByteCount = 0;
3792 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
3793 if (rc)
3794 cERROR(1, ("Send error in FindClose = %d", rc));
3796 cifs_stats_inc(&tcon->num_fclose);
3798 /* Since session is dead, search handle closed on server already */
3799 if (rc == -EAGAIN)
3800 rc = 0;
3802 return rc;
3806 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3807 const unsigned char *searchName,
3808 __u64 *inode_number,
3809 const struct nls_table *nls_codepage, int remap)
3811 int rc = 0;
3812 TRANSACTION2_QPI_REQ *pSMB = NULL;
3813 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3814 int name_len, bytes_returned;
3815 __u16 params, byte_count;
3817 cFYI(1, ("In GetSrvInodeNum for %s", searchName));
3818 if (tcon == NULL)
3819 return -ENODEV;
3821 GetInodeNumberRetry:
3822 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3823 (void **) &pSMBr);
3824 if (rc)
3825 return rc;
3827 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3828 name_len =
3829 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3830 PATH_MAX, nls_codepage, remap);
3831 name_len++; /* trailing null */
3832 name_len *= 2;
3833 } else { /* BB improve the check for buffer overruns BB */
3834 name_len = strnlen(searchName, PATH_MAX);
3835 name_len++; /* trailing null */
3836 strncpy(pSMB->FileName, searchName, name_len);
3839 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3840 pSMB->TotalDataCount = 0;
3841 pSMB->MaxParameterCount = cpu_to_le16(2);
3842 /* BB find exact max data count below from sess structure BB */
3843 pSMB->MaxDataCount = cpu_to_le16(4000);
3844 pSMB->MaxSetupCount = 0;
3845 pSMB->Reserved = 0;
3846 pSMB->Flags = 0;
3847 pSMB->Timeout = 0;
3848 pSMB->Reserved2 = 0;
3849 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3850 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3851 pSMB->DataCount = 0;
3852 pSMB->DataOffset = 0;
3853 pSMB->SetupCount = 1;
3854 pSMB->Reserved3 = 0;
3855 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3856 byte_count = params + 1 /* pad */ ;
3857 pSMB->TotalParameterCount = cpu_to_le16(params);
3858 pSMB->ParameterCount = pSMB->TotalParameterCount;
3859 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3860 pSMB->Reserved4 = 0;
3861 pSMB->hdr.smb_buf_length += byte_count;
3862 pSMB->ByteCount = cpu_to_le16(byte_count);
3864 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3865 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3866 if (rc) {
3867 cFYI(1, ("error %d in QueryInternalInfo", rc));
3868 } else {
3869 /* decode response */
3870 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3871 if (rc || (pSMBr->ByteCount < 2))
3872 /* BB also check enough total bytes returned */
3873 /* If rc should we check for EOPNOSUPP and
3874 disable the srvino flag? or in caller? */
3875 rc = -EIO; /* bad smb */
3876 else {
3877 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3878 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3879 struct file_internal_info *pfinfo;
3880 /* BB Do we need a cast or hash here ? */
3881 if (count < 8) {
3882 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3883 rc = -EIO;
3884 goto GetInodeNumOut;
3886 pfinfo = (struct file_internal_info *)
3887 (data_offset + (char *) &pSMBr->hdr.Protocol);
3888 *inode_number = pfinfo->UniqueId;
3891 GetInodeNumOut:
3892 cifs_buf_release(pSMB);
3893 if (rc == -EAGAIN)
3894 goto GetInodeNumberRetry;
3895 return rc;
3898 /* parses DFS refferal V3 structure
3899 * caller is responsible for freeing target_nodes
3900 * returns:
3901 * on success - 0
3902 * on failure - errno
3904 static int
3905 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
3906 unsigned int *num_of_nodes,
3907 struct dfs_info3_param **target_nodes,
3908 const struct nls_table *nls_codepage)
3910 int i, rc = 0;
3911 char *data_end;
3912 bool is_unicode;
3913 struct dfs_referral_level_3 *ref;
3915 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3916 is_unicode = true;
3917 else
3918 is_unicode = false;
3919 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
3921 if (*num_of_nodes < 1) {
3922 cERROR(1, ("num_referrals: must be at least > 0,"
3923 "but we get num_referrals = %d\n", *num_of_nodes));
3924 rc = -EINVAL;
3925 goto parse_DFS_referrals_exit;
3928 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
3929 if (ref->VersionNumber != cpu_to_le16(3)) {
3930 cERROR(1, ("Referrals of V%d version are not supported,"
3931 "should be V3", le16_to_cpu(ref->VersionNumber)));
3932 rc = -EINVAL;
3933 goto parse_DFS_referrals_exit;
3936 /* get the upper boundary of the resp buffer */
3937 data_end = (char *)(&(pSMBr->PathConsumed)) +
3938 le16_to_cpu(pSMBr->t2.DataCount);
3940 cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n",
3941 *num_of_nodes,
3942 le16_to_cpu(pSMBr->DFSFlags)));
3944 *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
3945 *num_of_nodes, GFP_KERNEL);
3946 if (*target_nodes == NULL) {
3947 cERROR(1, ("Failed to allocate buffer for target_nodes\n"));
3948 rc = -ENOMEM;
3949 goto parse_DFS_referrals_exit;
3952 /* collect neccessary data from referrals */
3953 for (i = 0; i < *num_of_nodes; i++) {
3954 char *temp;
3955 int max_len;
3956 struct dfs_info3_param *node = (*target_nodes)+i;
3958 node->flags = le16_to_cpu(pSMBr->DFSFlags);
3959 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
3960 node->server_type = le16_to_cpu(ref->ServerType);
3961 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
3963 /* copy DfsPath */
3964 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
3965 max_len = data_end - temp;
3966 rc = cifs_strncpy_to_host(&(node->path_name), temp,
3967 max_len, is_unicode, nls_codepage);
3968 if (rc)
3969 goto parse_DFS_referrals_exit;
3971 /* copy link target UNC */
3972 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
3973 max_len = data_end - temp;
3974 rc = cifs_strncpy_to_host(&(node->node_name), temp,
3975 max_len, is_unicode, nls_codepage);
3976 if (rc)
3977 goto parse_DFS_referrals_exit;
3979 ref += le16_to_cpu(ref->Size);
3982 parse_DFS_referrals_exit:
3983 if (rc) {
3984 free_dfs_info_array(*target_nodes, *num_of_nodes);
3985 *target_nodes = NULL;
3986 *num_of_nodes = 0;
3988 return rc;
3992 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3993 const unsigned char *searchName,
3994 struct dfs_info3_param **target_nodes,
3995 unsigned int *num_of_nodes,
3996 const struct nls_table *nls_codepage, int remap)
3998 /* TRANS2_GET_DFS_REFERRAL */
3999 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4000 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4001 int rc = 0;
4002 int bytes_returned;
4003 int name_len;
4004 __u16 params, byte_count;
4005 *num_of_nodes = 0;
4006 *target_nodes = NULL;
4008 cFYI(1, ("In GetDFSRefer the path %s", searchName));
4009 if (ses == NULL)
4010 return -ENODEV;
4011 getDFSRetry:
4012 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4013 (void **) &pSMBr);
4014 if (rc)
4015 return rc;
4017 /* server pointer checked in called function,
4018 but should never be null here anyway */
4019 pSMB->hdr.Mid = GetNextMid(ses->server);
4020 pSMB->hdr.Tid = ses->ipc_tid;
4021 pSMB->hdr.Uid = ses->Suid;
4022 if (ses->capabilities & CAP_STATUS32)
4023 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4024 if (ses->capabilities & CAP_DFS)
4025 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4027 if (ses->capabilities & CAP_UNICODE) {
4028 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4029 name_len =
4030 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
4031 searchName, PATH_MAX, nls_codepage, remap);
4032 name_len++; /* trailing null */
4033 name_len *= 2;
4034 } else { /* BB improve the check for buffer overruns BB */
4035 name_len = strnlen(searchName, PATH_MAX);
4036 name_len++; /* trailing null */
4037 strncpy(pSMB->RequestFileName, searchName, name_len);
4040 if (ses->server) {
4041 if (ses->server->secMode &
4042 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4043 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4046 pSMB->hdr.Uid = ses->Suid;
4048 params = 2 /* level */ + name_len /*includes null */ ;
4049 pSMB->TotalDataCount = 0;
4050 pSMB->DataCount = 0;
4051 pSMB->DataOffset = 0;
4052 pSMB->MaxParameterCount = 0;
4053 /* BB find exact max SMB PDU from sess structure BB */
4054 pSMB->MaxDataCount = cpu_to_le16(4000);
4055 pSMB->MaxSetupCount = 0;
4056 pSMB->Reserved = 0;
4057 pSMB->Flags = 0;
4058 pSMB->Timeout = 0;
4059 pSMB->Reserved2 = 0;
4060 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4061 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4062 pSMB->SetupCount = 1;
4063 pSMB->Reserved3 = 0;
4064 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4065 byte_count = params + 3 /* pad */ ;
4066 pSMB->ParameterCount = cpu_to_le16(params);
4067 pSMB->TotalParameterCount = pSMB->ParameterCount;
4068 pSMB->MaxReferralLevel = cpu_to_le16(3);
4069 pSMB->hdr.smb_buf_length += byte_count;
4070 pSMB->ByteCount = cpu_to_le16(byte_count);
4072 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4073 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4074 if (rc) {
4075 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
4076 goto GetDFSRefExit;
4078 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4080 /* BB Also check if enough total bytes returned? */
4081 if (rc || (pSMBr->ByteCount < 17)) {
4082 rc = -EIO; /* bad smb */
4083 goto GetDFSRefExit;
4086 cFYI(1, ("Decoding GetDFSRefer response BCC: %d Offset %d",
4087 pSMBr->ByteCount,
4088 le16_to_cpu(pSMBr->t2.DataOffset)));
4090 /* parse returned result into more usable form */
4091 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
4092 target_nodes, nls_codepage);
4094 GetDFSRefExit:
4095 cifs_buf_release(pSMB);
4097 if (rc == -EAGAIN)
4098 goto getDFSRetry;
4100 return rc;
4103 /* Query File System Info such as free space to old servers such as Win 9x */
4105 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4107 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4108 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4109 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4110 FILE_SYSTEM_ALLOC_INFO *response_data;
4111 int rc = 0;
4112 int bytes_returned = 0;
4113 __u16 params, byte_count;
4115 cFYI(1, ("OldQFSInfo"));
4116 oldQFSInfoRetry:
4117 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4118 (void **) &pSMBr);
4119 if (rc)
4120 return rc;
4122 params = 2; /* level */
4123 pSMB->TotalDataCount = 0;
4124 pSMB->MaxParameterCount = cpu_to_le16(2);
4125 pSMB->MaxDataCount = cpu_to_le16(1000);
4126 pSMB->MaxSetupCount = 0;
4127 pSMB->Reserved = 0;
4128 pSMB->Flags = 0;
4129 pSMB->Timeout = 0;
4130 pSMB->Reserved2 = 0;
4131 byte_count = params + 1 /* pad */ ;
4132 pSMB->TotalParameterCount = cpu_to_le16(params);
4133 pSMB->ParameterCount = pSMB->TotalParameterCount;
4134 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4135 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4136 pSMB->DataCount = 0;
4137 pSMB->DataOffset = 0;
4138 pSMB->SetupCount = 1;
4139 pSMB->Reserved3 = 0;
4140 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4141 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4142 pSMB->hdr.smb_buf_length += byte_count;
4143 pSMB->ByteCount = cpu_to_le16(byte_count);
4145 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4146 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4147 if (rc) {
4148 cFYI(1, ("Send error in QFSInfo = %d", rc));
4149 } else { /* decode response */
4150 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4152 if (rc || (pSMBr->ByteCount < 18))
4153 rc = -EIO; /* bad smb */
4154 else {
4155 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4156 cFYI(1, ("qfsinf resp BCC: %d Offset %d",
4157 pSMBr->ByteCount, data_offset));
4159 response_data = (FILE_SYSTEM_ALLOC_INFO *)
4160 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4161 FSData->f_bsize =
4162 le16_to_cpu(response_data->BytesPerSector) *
4163 le32_to_cpu(response_data->
4164 SectorsPerAllocationUnit);
4165 FSData->f_blocks =
4166 le32_to_cpu(response_data->TotalAllocationUnits);
4167 FSData->f_bfree = FSData->f_bavail =
4168 le32_to_cpu(response_data->FreeAllocationUnits);
4169 cFYI(1,
4170 ("Blocks: %lld Free: %lld Block size %ld",
4171 (unsigned long long)FSData->f_blocks,
4172 (unsigned long long)FSData->f_bfree,
4173 FSData->f_bsize));
4176 cifs_buf_release(pSMB);
4178 if (rc == -EAGAIN)
4179 goto oldQFSInfoRetry;
4181 return rc;
4185 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4187 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4188 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4189 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4190 FILE_SYSTEM_INFO *response_data;
4191 int rc = 0;
4192 int bytes_returned = 0;
4193 __u16 params, byte_count;
4195 cFYI(1, ("In QFSInfo"));
4196 QFSInfoRetry:
4197 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4198 (void **) &pSMBr);
4199 if (rc)
4200 return rc;
4202 params = 2; /* level */
4203 pSMB->TotalDataCount = 0;
4204 pSMB->MaxParameterCount = cpu_to_le16(2);
4205 pSMB->MaxDataCount = cpu_to_le16(1000);
4206 pSMB->MaxSetupCount = 0;
4207 pSMB->Reserved = 0;
4208 pSMB->Flags = 0;
4209 pSMB->Timeout = 0;
4210 pSMB->Reserved2 = 0;
4211 byte_count = params + 1 /* pad */ ;
4212 pSMB->TotalParameterCount = cpu_to_le16(params);
4213 pSMB->ParameterCount = pSMB->TotalParameterCount;
4214 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4215 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4216 pSMB->DataCount = 0;
4217 pSMB->DataOffset = 0;
4218 pSMB->SetupCount = 1;
4219 pSMB->Reserved3 = 0;
4220 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4221 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4222 pSMB->hdr.smb_buf_length += byte_count;
4223 pSMB->ByteCount = cpu_to_le16(byte_count);
4225 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4226 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4227 if (rc) {
4228 cFYI(1, ("Send error in QFSInfo = %d", rc));
4229 } else { /* decode response */
4230 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4232 if (rc || (pSMBr->ByteCount < 24))
4233 rc = -EIO; /* bad smb */
4234 else {
4235 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4237 response_data =
4238 (FILE_SYSTEM_INFO
4239 *) (((char *) &pSMBr->hdr.Protocol) +
4240 data_offset);
4241 FSData->f_bsize =
4242 le32_to_cpu(response_data->BytesPerSector) *
4243 le32_to_cpu(response_data->
4244 SectorsPerAllocationUnit);
4245 FSData->f_blocks =
4246 le64_to_cpu(response_data->TotalAllocationUnits);
4247 FSData->f_bfree = FSData->f_bavail =
4248 le64_to_cpu(response_data->FreeAllocationUnits);
4249 cFYI(1,
4250 ("Blocks: %lld Free: %lld Block size %ld",
4251 (unsigned long long)FSData->f_blocks,
4252 (unsigned long long)FSData->f_bfree,
4253 FSData->f_bsize));
4256 cifs_buf_release(pSMB);
4258 if (rc == -EAGAIN)
4259 goto QFSInfoRetry;
4261 return rc;
4265 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
4267 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
4268 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4269 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4270 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4271 int rc = 0;
4272 int bytes_returned = 0;
4273 __u16 params, byte_count;
4275 cFYI(1, ("In QFSAttributeInfo"));
4276 QFSAttributeRetry:
4277 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4278 (void **) &pSMBr);
4279 if (rc)
4280 return rc;
4282 params = 2; /* level */
4283 pSMB->TotalDataCount = 0;
4284 pSMB->MaxParameterCount = cpu_to_le16(2);
4285 /* BB find exact max SMB PDU from sess structure BB */
4286 pSMB->MaxDataCount = cpu_to_le16(1000);
4287 pSMB->MaxSetupCount = 0;
4288 pSMB->Reserved = 0;
4289 pSMB->Flags = 0;
4290 pSMB->Timeout = 0;
4291 pSMB->Reserved2 = 0;
4292 byte_count = params + 1 /* pad */ ;
4293 pSMB->TotalParameterCount = cpu_to_le16(params);
4294 pSMB->ParameterCount = pSMB->TotalParameterCount;
4295 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4296 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4297 pSMB->DataCount = 0;
4298 pSMB->DataOffset = 0;
4299 pSMB->SetupCount = 1;
4300 pSMB->Reserved3 = 0;
4301 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4302 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4303 pSMB->hdr.smb_buf_length += byte_count;
4304 pSMB->ByteCount = cpu_to_le16(byte_count);
4306 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4307 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4308 if (rc) {
4309 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
4310 } else { /* decode response */
4311 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4313 if (rc || (pSMBr->ByteCount < 13)) {
4314 /* BB also check if enough bytes returned */
4315 rc = -EIO; /* bad smb */
4316 } else {
4317 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4318 response_data =
4319 (FILE_SYSTEM_ATTRIBUTE_INFO
4320 *) (((char *) &pSMBr->hdr.Protocol) +
4321 data_offset);
4322 memcpy(&tcon->fsAttrInfo, response_data,
4323 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4326 cifs_buf_release(pSMB);
4328 if (rc == -EAGAIN)
4329 goto QFSAttributeRetry;
4331 return rc;
4335 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
4337 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4338 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4339 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4340 FILE_SYSTEM_DEVICE_INFO *response_data;
4341 int rc = 0;
4342 int bytes_returned = 0;
4343 __u16 params, byte_count;
4345 cFYI(1, ("In QFSDeviceInfo"));
4346 QFSDeviceRetry:
4347 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4348 (void **) &pSMBr);
4349 if (rc)
4350 return rc;
4352 params = 2; /* level */
4353 pSMB->TotalDataCount = 0;
4354 pSMB->MaxParameterCount = cpu_to_le16(2);
4355 /* BB find exact max SMB PDU from sess structure BB */
4356 pSMB->MaxDataCount = cpu_to_le16(1000);
4357 pSMB->MaxSetupCount = 0;
4358 pSMB->Reserved = 0;
4359 pSMB->Flags = 0;
4360 pSMB->Timeout = 0;
4361 pSMB->Reserved2 = 0;
4362 byte_count = params + 1 /* pad */ ;
4363 pSMB->TotalParameterCount = cpu_to_le16(params);
4364 pSMB->ParameterCount = pSMB->TotalParameterCount;
4365 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4366 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4368 pSMB->DataCount = 0;
4369 pSMB->DataOffset = 0;
4370 pSMB->SetupCount = 1;
4371 pSMB->Reserved3 = 0;
4372 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4373 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4374 pSMB->hdr.smb_buf_length += byte_count;
4375 pSMB->ByteCount = cpu_to_le16(byte_count);
4377 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4378 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4379 if (rc) {
4380 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
4381 } else { /* decode response */
4382 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4384 if (rc || (pSMBr->ByteCount < sizeof(FILE_SYSTEM_DEVICE_INFO)))
4385 rc = -EIO; /* bad smb */
4386 else {
4387 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4388 response_data =
4389 (FILE_SYSTEM_DEVICE_INFO *)
4390 (((char *) &pSMBr->hdr.Protocol) +
4391 data_offset);
4392 memcpy(&tcon->fsDevInfo, response_data,
4393 sizeof(FILE_SYSTEM_DEVICE_INFO));
4396 cifs_buf_release(pSMB);
4398 if (rc == -EAGAIN)
4399 goto QFSDeviceRetry;
4401 return rc;
4405 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
4407 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
4408 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4409 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4410 FILE_SYSTEM_UNIX_INFO *response_data;
4411 int rc = 0;
4412 int bytes_returned = 0;
4413 __u16 params, byte_count;
4415 cFYI(1, ("In QFSUnixInfo"));
4416 QFSUnixRetry:
4417 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4418 (void **) &pSMBr);
4419 if (rc)
4420 return rc;
4422 params = 2; /* level */
4423 pSMB->TotalDataCount = 0;
4424 pSMB->DataCount = 0;
4425 pSMB->DataOffset = 0;
4426 pSMB->MaxParameterCount = cpu_to_le16(2);
4427 /* BB find exact max SMB PDU from sess structure BB */
4428 pSMB->MaxDataCount = cpu_to_le16(100);
4429 pSMB->MaxSetupCount = 0;
4430 pSMB->Reserved = 0;
4431 pSMB->Flags = 0;
4432 pSMB->Timeout = 0;
4433 pSMB->Reserved2 = 0;
4434 byte_count = params + 1 /* pad */ ;
4435 pSMB->ParameterCount = cpu_to_le16(params);
4436 pSMB->TotalParameterCount = pSMB->ParameterCount;
4437 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4438 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4439 pSMB->SetupCount = 1;
4440 pSMB->Reserved3 = 0;
4441 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4442 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4443 pSMB->hdr.smb_buf_length += byte_count;
4444 pSMB->ByteCount = cpu_to_le16(byte_count);
4446 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4447 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4448 if (rc) {
4449 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
4450 } else { /* decode response */
4451 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4453 if (rc || (pSMBr->ByteCount < 13)) {
4454 rc = -EIO; /* bad smb */
4455 } else {
4456 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4457 response_data =
4458 (FILE_SYSTEM_UNIX_INFO
4459 *) (((char *) &pSMBr->hdr.Protocol) +
4460 data_offset);
4461 memcpy(&tcon->fsUnixInfo, response_data,
4462 sizeof(FILE_SYSTEM_UNIX_INFO));
4465 cifs_buf_release(pSMB);
4467 if (rc == -EAGAIN)
4468 goto QFSUnixRetry;
4471 return rc;
4475 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
4477 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
4478 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4479 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4480 int rc = 0;
4481 int bytes_returned = 0;
4482 __u16 params, param_offset, offset, byte_count;
4484 cFYI(1, ("In SETFSUnixInfo"));
4485 SETFSUnixRetry:
4486 /* BB switch to small buf init to save memory */
4487 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4488 (void **) &pSMBr);
4489 if (rc)
4490 return rc;
4492 params = 4; /* 2 bytes zero followed by info level. */
4493 pSMB->MaxSetupCount = 0;
4494 pSMB->Reserved = 0;
4495 pSMB->Flags = 0;
4496 pSMB->Timeout = 0;
4497 pSMB->Reserved2 = 0;
4498 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4499 - 4;
4500 offset = param_offset + params;
4502 pSMB->MaxParameterCount = cpu_to_le16(4);
4503 /* BB find exact max SMB PDU from sess structure BB */
4504 pSMB->MaxDataCount = cpu_to_le16(100);
4505 pSMB->SetupCount = 1;
4506 pSMB->Reserved3 = 0;
4507 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4508 byte_count = 1 /* pad */ + params + 12;
4510 pSMB->DataCount = cpu_to_le16(12);
4511 pSMB->ParameterCount = cpu_to_le16(params);
4512 pSMB->TotalDataCount = pSMB->DataCount;
4513 pSMB->TotalParameterCount = pSMB->ParameterCount;
4514 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4515 pSMB->DataOffset = cpu_to_le16(offset);
4517 /* Params. */
4518 pSMB->FileNum = 0;
4519 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4521 /* Data. */
4522 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4523 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4524 pSMB->ClientUnixCap = cpu_to_le64(cap);
4526 pSMB->hdr.smb_buf_length += byte_count;
4527 pSMB->ByteCount = cpu_to_le16(byte_count);
4529 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4530 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4531 if (rc) {
4532 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
4533 } else { /* decode response */
4534 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4535 if (rc)
4536 rc = -EIO; /* bad smb */
4538 cifs_buf_release(pSMB);
4540 if (rc == -EAGAIN)
4541 goto SETFSUnixRetry;
4543 return rc;
4549 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
4550 struct kstatfs *FSData)
4552 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
4553 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4554 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4555 FILE_SYSTEM_POSIX_INFO *response_data;
4556 int rc = 0;
4557 int bytes_returned = 0;
4558 __u16 params, byte_count;
4560 cFYI(1, ("In QFSPosixInfo"));
4561 QFSPosixRetry:
4562 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4563 (void **) &pSMBr);
4564 if (rc)
4565 return rc;
4567 params = 2; /* level */
4568 pSMB->TotalDataCount = 0;
4569 pSMB->DataCount = 0;
4570 pSMB->DataOffset = 0;
4571 pSMB->MaxParameterCount = cpu_to_le16(2);
4572 /* BB find exact max SMB PDU from sess structure BB */
4573 pSMB->MaxDataCount = cpu_to_le16(100);
4574 pSMB->MaxSetupCount = 0;
4575 pSMB->Reserved = 0;
4576 pSMB->Flags = 0;
4577 pSMB->Timeout = 0;
4578 pSMB->Reserved2 = 0;
4579 byte_count = params + 1 /* pad */ ;
4580 pSMB->ParameterCount = cpu_to_le16(params);
4581 pSMB->TotalParameterCount = pSMB->ParameterCount;
4582 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4583 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4584 pSMB->SetupCount = 1;
4585 pSMB->Reserved3 = 0;
4586 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4587 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4588 pSMB->hdr.smb_buf_length += byte_count;
4589 pSMB->ByteCount = cpu_to_le16(byte_count);
4591 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4592 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4593 if (rc) {
4594 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
4595 } else { /* decode response */
4596 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4598 if (rc || (pSMBr->ByteCount < 13)) {
4599 rc = -EIO; /* bad smb */
4600 } else {
4601 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4602 response_data =
4603 (FILE_SYSTEM_POSIX_INFO
4604 *) (((char *) &pSMBr->hdr.Protocol) +
4605 data_offset);
4606 FSData->f_bsize =
4607 le32_to_cpu(response_data->BlockSize);
4608 FSData->f_blocks =
4609 le64_to_cpu(response_data->TotalBlocks);
4610 FSData->f_bfree =
4611 le64_to_cpu(response_data->BlocksAvail);
4612 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4613 FSData->f_bavail = FSData->f_bfree;
4614 } else {
4615 FSData->f_bavail =
4616 le64_to_cpu(response_data->UserBlocksAvail);
4618 if (response_data->TotalFileNodes != cpu_to_le64(-1))
4619 FSData->f_files =
4620 le64_to_cpu(response_data->TotalFileNodes);
4621 if (response_data->FreeFileNodes != cpu_to_le64(-1))
4622 FSData->f_ffree =
4623 le64_to_cpu(response_data->FreeFileNodes);
4626 cifs_buf_release(pSMB);
4628 if (rc == -EAGAIN)
4629 goto QFSPosixRetry;
4631 return rc;
4635 /* We can not use write of zero bytes trick to
4636 set file size due to need for large file support. Also note that
4637 this SetPathInfo is preferred to SetFileInfo based method in next
4638 routine which is only needed to work around a sharing violation bug
4639 in Samba which this routine can run into */
4642 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4643 __u64 size, bool SetAllocation,
4644 const struct nls_table *nls_codepage, int remap)
4646 struct smb_com_transaction2_spi_req *pSMB = NULL;
4647 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4648 struct file_end_of_file_info *parm_data;
4649 int name_len;
4650 int rc = 0;
4651 int bytes_returned = 0;
4652 __u16 params, byte_count, data_count, param_offset, offset;
4654 cFYI(1, ("In SetEOF"));
4655 SetEOFRetry:
4656 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4657 (void **) &pSMBr);
4658 if (rc)
4659 return rc;
4661 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4662 name_len =
4663 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4664 PATH_MAX, nls_codepage, remap);
4665 name_len++; /* trailing null */
4666 name_len *= 2;
4667 } else { /* BB improve the check for buffer overruns BB */
4668 name_len = strnlen(fileName, PATH_MAX);
4669 name_len++; /* trailing null */
4670 strncpy(pSMB->FileName, fileName, name_len);
4672 params = 6 + name_len;
4673 data_count = sizeof(struct file_end_of_file_info);
4674 pSMB->MaxParameterCount = cpu_to_le16(2);
4675 pSMB->MaxDataCount = cpu_to_le16(4100);
4676 pSMB->MaxSetupCount = 0;
4677 pSMB->Reserved = 0;
4678 pSMB->Flags = 0;
4679 pSMB->Timeout = 0;
4680 pSMB->Reserved2 = 0;
4681 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4682 InformationLevel) - 4;
4683 offset = param_offset + params;
4684 if (SetAllocation) {
4685 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4686 pSMB->InformationLevel =
4687 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4688 else
4689 pSMB->InformationLevel =
4690 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4691 } else /* Set File Size */ {
4692 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4693 pSMB->InformationLevel =
4694 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4695 else
4696 pSMB->InformationLevel =
4697 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4700 parm_data =
4701 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4702 offset);
4703 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4704 pSMB->DataOffset = cpu_to_le16(offset);
4705 pSMB->SetupCount = 1;
4706 pSMB->Reserved3 = 0;
4707 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4708 byte_count = 3 /* pad */ + params + data_count;
4709 pSMB->DataCount = cpu_to_le16(data_count);
4710 pSMB->TotalDataCount = pSMB->DataCount;
4711 pSMB->ParameterCount = cpu_to_le16(params);
4712 pSMB->TotalParameterCount = pSMB->ParameterCount;
4713 pSMB->Reserved4 = 0;
4714 pSMB->hdr.smb_buf_length += byte_count;
4715 parm_data->FileSize = cpu_to_le64(size);
4716 pSMB->ByteCount = cpu_to_le16(byte_count);
4717 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4718 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4719 if (rc)
4720 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4722 cifs_buf_release(pSMB);
4724 if (rc == -EAGAIN)
4725 goto SetEOFRetry;
4727 return rc;
4731 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4732 __u16 fid, __u32 pid_of_opener, bool SetAllocation)
4734 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4735 char *data_offset;
4736 struct file_end_of_file_info *parm_data;
4737 int rc = 0;
4738 __u16 params, param_offset, offset, byte_count, count;
4740 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4741 (long long)size));
4742 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4744 if (rc)
4745 return rc;
4747 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4748 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4750 params = 6;
4751 pSMB->MaxSetupCount = 0;
4752 pSMB->Reserved = 0;
4753 pSMB->Flags = 0;
4754 pSMB->Timeout = 0;
4755 pSMB->Reserved2 = 0;
4756 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4757 offset = param_offset + params;
4759 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4761 count = sizeof(struct file_end_of_file_info);
4762 pSMB->MaxParameterCount = cpu_to_le16(2);
4763 /* BB find exact max SMB PDU from sess structure BB */
4764 pSMB->MaxDataCount = cpu_to_le16(1000);
4765 pSMB->SetupCount = 1;
4766 pSMB->Reserved3 = 0;
4767 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4768 byte_count = 3 /* pad */ + params + count;
4769 pSMB->DataCount = cpu_to_le16(count);
4770 pSMB->ParameterCount = cpu_to_le16(params);
4771 pSMB->TotalDataCount = pSMB->DataCount;
4772 pSMB->TotalParameterCount = pSMB->ParameterCount;
4773 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4774 parm_data =
4775 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
4776 + offset);
4777 pSMB->DataOffset = cpu_to_le16(offset);
4778 parm_data->FileSize = cpu_to_le64(size);
4779 pSMB->Fid = fid;
4780 if (SetAllocation) {
4781 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4782 pSMB->InformationLevel =
4783 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4784 else
4785 pSMB->InformationLevel =
4786 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4787 } else /* Set File Size */ {
4788 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4789 pSMB->InformationLevel =
4790 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4791 else
4792 pSMB->InformationLevel =
4793 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4795 pSMB->Reserved4 = 0;
4796 pSMB->hdr.smb_buf_length += byte_count;
4797 pSMB->ByteCount = cpu_to_le16(byte_count);
4798 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
4799 if (rc) {
4800 cFYI(1,
4801 ("Send error in SetFileInfo (SetFileSize) = %d",
4802 rc));
4805 /* Note: On -EAGAIN error only caller can retry on handle based calls
4806 since file handle passed in no longer valid */
4808 return rc;
4811 /* Some legacy servers such as NT4 require that the file times be set on
4812 an open handle, rather than by pathname - this is awkward due to
4813 potential access conflicts on the open, but it is unavoidable for these
4814 old servers since the only other choice is to go from 100 nanosecond DCE
4815 time and resort to the original setpathinfo level which takes the ancient
4816 DOS time format with 2 second granularity */
4818 CIFSSMBSetFileInfo(const int xid, struct cifsTconInfo *tcon,
4819 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
4821 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4822 char *data_offset;
4823 int rc = 0;
4824 __u16 params, param_offset, offset, byte_count, count;
4826 cFYI(1, ("Set Times (via SetFileInfo)"));
4827 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4829 if (rc)
4830 return rc;
4832 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4833 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4835 params = 6;
4836 pSMB->MaxSetupCount = 0;
4837 pSMB->Reserved = 0;
4838 pSMB->Flags = 0;
4839 pSMB->Timeout = 0;
4840 pSMB->Reserved2 = 0;
4841 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4842 offset = param_offset + params;
4844 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4846 count = sizeof(FILE_BASIC_INFO);
4847 pSMB->MaxParameterCount = cpu_to_le16(2);
4848 /* BB find max SMB PDU from sess */
4849 pSMB->MaxDataCount = cpu_to_le16(1000);
4850 pSMB->SetupCount = 1;
4851 pSMB->Reserved3 = 0;
4852 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4853 byte_count = 3 /* pad */ + params + count;
4854 pSMB->DataCount = cpu_to_le16(count);
4855 pSMB->ParameterCount = cpu_to_le16(params);
4856 pSMB->TotalDataCount = pSMB->DataCount;
4857 pSMB->TotalParameterCount = pSMB->ParameterCount;
4858 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4859 pSMB->DataOffset = cpu_to_le16(offset);
4860 pSMB->Fid = fid;
4861 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4862 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4863 else
4864 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4865 pSMB->Reserved4 = 0;
4866 pSMB->hdr.smb_buf_length += byte_count;
4867 pSMB->ByteCount = cpu_to_le16(byte_count);
4868 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4869 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
4870 if (rc)
4871 cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
4873 /* Note: On -EAGAIN error only caller can retry on handle based calls
4874 since file handle passed in no longer valid */
4876 return rc;
4881 CIFSSMBSetPathInfo(const int xid, struct cifsTconInfo *tcon,
4882 const char *fileName, const FILE_BASIC_INFO *data,
4883 const struct nls_table *nls_codepage, int remap)
4885 TRANSACTION2_SPI_REQ *pSMB = NULL;
4886 TRANSACTION2_SPI_RSP *pSMBr = NULL;
4887 int name_len;
4888 int rc = 0;
4889 int bytes_returned = 0;
4890 char *data_offset;
4891 __u16 params, param_offset, offset, byte_count, count;
4893 cFYI(1, ("In SetTimes"));
4895 SetTimesRetry:
4896 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4897 (void **) &pSMBr);
4898 if (rc)
4899 return rc;
4901 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4902 name_len =
4903 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4904 PATH_MAX, nls_codepage, remap);
4905 name_len++; /* trailing null */
4906 name_len *= 2;
4907 } else { /* BB improve the check for buffer overruns BB */
4908 name_len = strnlen(fileName, PATH_MAX);
4909 name_len++; /* trailing null */
4910 strncpy(pSMB->FileName, fileName, name_len);
4913 params = 6 + name_len;
4914 count = sizeof(FILE_BASIC_INFO);
4915 pSMB->MaxParameterCount = cpu_to_le16(2);
4916 /* BB find max SMB PDU from sess structure BB */
4917 pSMB->MaxDataCount = cpu_to_le16(1000);
4918 pSMB->MaxSetupCount = 0;
4919 pSMB->Reserved = 0;
4920 pSMB->Flags = 0;
4921 pSMB->Timeout = 0;
4922 pSMB->Reserved2 = 0;
4923 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4924 InformationLevel) - 4;
4925 offset = param_offset + params;
4926 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4927 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4928 pSMB->DataOffset = cpu_to_le16(offset);
4929 pSMB->SetupCount = 1;
4930 pSMB->Reserved3 = 0;
4931 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4932 byte_count = 3 /* pad */ + params + count;
4934 pSMB->DataCount = cpu_to_le16(count);
4935 pSMB->ParameterCount = cpu_to_le16(params);
4936 pSMB->TotalDataCount = pSMB->DataCount;
4937 pSMB->TotalParameterCount = pSMB->ParameterCount;
4938 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4939 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4940 else
4941 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4942 pSMB->Reserved4 = 0;
4943 pSMB->hdr.smb_buf_length += byte_count;
4944 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4945 pSMB->ByteCount = cpu_to_le16(byte_count);
4946 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4947 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4948 if (rc)
4949 cFYI(1, ("SetPathInfo (times) returned %d", rc));
4951 cifs_buf_release(pSMB);
4953 if (rc == -EAGAIN)
4954 goto SetTimesRetry;
4956 return rc;
4959 /* Can not be used to set time stamps yet (due to old DOS time format) */
4960 /* Can be used to set attributes */
4961 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
4962 handling it anyway and NT4 was what we thought it would be needed for
4963 Do not delete it until we prove whether needed for Win9x though */
4965 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
4966 __u16 dos_attrs, const struct nls_table *nls_codepage)
4968 SETATTR_REQ *pSMB = NULL;
4969 SETATTR_RSP *pSMBr = NULL;
4970 int rc = 0;
4971 int bytes_returned;
4972 int name_len;
4974 cFYI(1, ("In SetAttrLegacy"));
4976 SetAttrLgcyRetry:
4977 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
4978 (void **) &pSMBr);
4979 if (rc)
4980 return rc;
4982 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4983 name_len =
4984 ConvertToUCS((__le16 *) pSMB->fileName, fileName,
4985 PATH_MAX, nls_codepage);
4986 name_len++; /* trailing null */
4987 name_len *= 2;
4988 } else { /* BB improve the check for buffer overruns BB */
4989 name_len = strnlen(fileName, PATH_MAX);
4990 name_len++; /* trailing null */
4991 strncpy(pSMB->fileName, fileName, name_len);
4993 pSMB->attr = cpu_to_le16(dos_attrs);
4994 pSMB->BufferFormat = 0x04;
4995 pSMB->hdr.smb_buf_length += name_len + 1;
4996 pSMB->ByteCount = cpu_to_le16(name_len + 1);
4997 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4998 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4999 if (rc)
5000 cFYI(1, ("Error in LegacySetAttr = %d", rc));
5002 cifs_buf_release(pSMB);
5004 if (rc == -EAGAIN)
5005 goto SetAttrLgcyRetry;
5007 return rc;
5009 #endif /* temporarily unneeded SetAttr legacy function */
5012 CIFSSMBUnixSetInfo(const int xid, struct cifsTconInfo *tcon, char *fileName,
5013 const struct cifs_unix_set_info_args *args,
5014 const struct nls_table *nls_codepage, int remap)
5016 TRANSACTION2_SPI_REQ *pSMB = NULL;
5017 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5018 int name_len;
5019 int rc = 0;
5020 int bytes_returned = 0;
5021 FILE_UNIX_BASIC_INFO *data_offset;
5022 __u16 params, param_offset, offset, count, byte_count;
5023 __u64 mode = args->mode;
5025 cFYI(1, ("In SetUID/GID/Mode"));
5026 setPermsRetry:
5027 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5028 (void **) &pSMBr);
5029 if (rc)
5030 return rc;
5032 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5033 name_len =
5034 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5035 PATH_MAX, nls_codepage, remap);
5036 name_len++; /* trailing null */
5037 name_len *= 2;
5038 } else { /* BB improve the check for buffer overruns BB */
5039 name_len = strnlen(fileName, PATH_MAX);
5040 name_len++; /* trailing null */
5041 strncpy(pSMB->FileName, fileName, name_len);
5044 params = 6 + name_len;
5045 count = sizeof(FILE_UNIX_BASIC_INFO);
5046 pSMB->MaxParameterCount = cpu_to_le16(2);
5047 /* BB find max SMB PDU from sess structure BB */
5048 pSMB->MaxDataCount = cpu_to_le16(1000);
5049 pSMB->MaxSetupCount = 0;
5050 pSMB->Reserved = 0;
5051 pSMB->Flags = 0;
5052 pSMB->Timeout = 0;
5053 pSMB->Reserved2 = 0;
5054 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5055 InformationLevel) - 4;
5056 offset = param_offset + params;
5057 data_offset =
5058 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
5059 offset);
5060 memset(data_offset, 0, count);
5061 pSMB->DataOffset = cpu_to_le16(offset);
5062 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5063 pSMB->SetupCount = 1;
5064 pSMB->Reserved3 = 0;
5065 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5066 byte_count = 3 /* pad */ + params + count;
5067 pSMB->ParameterCount = cpu_to_le16(params);
5068 pSMB->DataCount = cpu_to_le16(count);
5069 pSMB->TotalParameterCount = pSMB->ParameterCount;
5070 pSMB->TotalDataCount = pSMB->DataCount;
5071 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5072 pSMB->Reserved4 = 0;
5073 pSMB->hdr.smb_buf_length += byte_count;
5074 /* Samba server ignores set of file size to zero due to bugs in some
5075 older clients, but we should be precise - we use SetFileSize to
5076 set file size and do not want to truncate file size to zero
5077 accidently as happened on one Samba server beta by putting
5078 zero instead of -1 here */
5079 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5080 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5081 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5082 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5083 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5084 data_offset->Uid = cpu_to_le64(args->uid);
5085 data_offset->Gid = cpu_to_le64(args->gid);
5086 /* better to leave device as zero when it is */
5087 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5088 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5089 data_offset->Permissions = cpu_to_le64(mode);
5091 if (S_ISREG(mode))
5092 data_offset->Type = cpu_to_le32(UNIX_FILE);
5093 else if (S_ISDIR(mode))
5094 data_offset->Type = cpu_to_le32(UNIX_DIR);
5095 else if (S_ISLNK(mode))
5096 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5097 else if (S_ISCHR(mode))
5098 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5099 else if (S_ISBLK(mode))
5100 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5101 else if (S_ISFIFO(mode))
5102 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5103 else if (S_ISSOCK(mode))
5104 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5107 pSMB->ByteCount = cpu_to_le16(byte_count);
5108 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5109 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5110 if (rc)
5111 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
5113 cifs_buf_release(pSMB);
5114 if (rc == -EAGAIN)
5115 goto setPermsRetry;
5116 return rc;
5119 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
5120 const int notify_subdirs, const __u16 netfid,
5121 __u32 filter, struct file *pfile, int multishot,
5122 const struct nls_table *nls_codepage)
5124 int rc = 0;
5125 struct smb_com_transaction_change_notify_req *pSMB = NULL;
5126 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
5127 struct dir_notify_req *dnotify_req;
5128 int bytes_returned;
5130 cFYI(1, ("In CIFSSMBNotify for file handle %d", (int)netfid));
5131 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
5132 (void **) &pSMBr);
5133 if (rc)
5134 return rc;
5136 pSMB->TotalParameterCount = 0 ;
5137 pSMB->TotalDataCount = 0;
5138 pSMB->MaxParameterCount = cpu_to_le32(2);
5139 /* BB find exact data count max from sess structure BB */
5140 pSMB->MaxDataCount = 0; /* same in little endian or be */
5141 /* BB VERIFY verify which is correct for above BB */
5142 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
5143 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
5145 pSMB->MaxSetupCount = 4;
5146 pSMB->Reserved = 0;
5147 pSMB->ParameterOffset = 0;
5148 pSMB->DataCount = 0;
5149 pSMB->DataOffset = 0;
5150 pSMB->SetupCount = 4; /* single byte does not need le conversion */
5151 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
5152 pSMB->ParameterCount = pSMB->TotalParameterCount;
5153 if (notify_subdirs)
5154 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
5155 pSMB->Reserved2 = 0;
5156 pSMB->CompletionFilter = cpu_to_le32(filter);
5157 pSMB->Fid = netfid; /* file handle always le */
5158 pSMB->ByteCount = 0;
5160 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5161 (struct smb_hdr *)pSMBr, &bytes_returned,
5162 CIFS_ASYNC_OP);
5163 if (rc) {
5164 cFYI(1, ("Error in Notify = %d", rc));
5165 } else {
5166 /* Add file to outstanding requests */
5167 /* BB change to kmem cache alloc */
5168 dnotify_req = kmalloc(
5169 sizeof(struct dir_notify_req),
5170 GFP_KERNEL);
5171 if (dnotify_req) {
5172 dnotify_req->Pid = pSMB->hdr.Pid;
5173 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
5174 dnotify_req->Mid = pSMB->hdr.Mid;
5175 dnotify_req->Tid = pSMB->hdr.Tid;
5176 dnotify_req->Uid = pSMB->hdr.Uid;
5177 dnotify_req->netfid = netfid;
5178 dnotify_req->pfile = pfile;
5179 dnotify_req->filter = filter;
5180 dnotify_req->multishot = multishot;
5181 spin_lock(&GlobalMid_Lock);
5182 list_add_tail(&dnotify_req->lhead,
5183 &GlobalDnotifyReqList);
5184 spin_unlock(&GlobalMid_Lock);
5185 } else
5186 rc = -ENOMEM;
5188 cifs_buf_release(pSMB);
5189 return rc;
5191 #ifdef CONFIG_CIFS_XATTR
5192 ssize_t
5193 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
5194 const unsigned char *searchName,
5195 char *EAData, size_t buf_size,
5196 const struct nls_table *nls_codepage, int remap)
5198 /* BB assumes one setup word */
5199 TRANSACTION2_QPI_REQ *pSMB = NULL;
5200 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5201 int rc = 0;
5202 int bytes_returned;
5203 int name_len;
5204 struct fea *temp_fea;
5205 char *temp_ptr;
5206 __u16 params, byte_count;
5208 cFYI(1, ("In Query All EAs path %s", searchName));
5209 QAllEAsRetry:
5210 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5211 (void **) &pSMBr);
5212 if (rc)
5213 return rc;
5215 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5216 name_len =
5217 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5218 PATH_MAX, nls_codepage, remap);
5219 name_len++; /* trailing null */
5220 name_len *= 2;
5221 } else { /* BB improve the check for buffer overruns BB */
5222 name_len = strnlen(searchName, PATH_MAX);
5223 name_len++; /* trailing null */
5224 strncpy(pSMB->FileName, searchName, name_len);
5227 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5228 pSMB->TotalDataCount = 0;
5229 pSMB->MaxParameterCount = cpu_to_le16(2);
5230 /* BB find exact max SMB PDU from sess structure BB */
5231 pSMB->MaxDataCount = cpu_to_le16(4000);
5232 pSMB->MaxSetupCount = 0;
5233 pSMB->Reserved = 0;
5234 pSMB->Flags = 0;
5235 pSMB->Timeout = 0;
5236 pSMB->Reserved2 = 0;
5237 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5238 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5239 pSMB->DataCount = 0;
5240 pSMB->DataOffset = 0;
5241 pSMB->SetupCount = 1;
5242 pSMB->Reserved3 = 0;
5243 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5244 byte_count = params + 1 /* pad */ ;
5245 pSMB->TotalParameterCount = cpu_to_le16(params);
5246 pSMB->ParameterCount = pSMB->TotalParameterCount;
5247 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5248 pSMB->Reserved4 = 0;
5249 pSMB->hdr.smb_buf_length += byte_count;
5250 pSMB->ByteCount = cpu_to_le16(byte_count);
5252 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5253 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5254 if (rc) {
5255 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
5256 } else { /* decode response */
5257 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5259 /* BB also check enough total bytes returned */
5260 /* BB we need to improve the validity checking
5261 of these trans2 responses */
5262 if (rc || (pSMBr->ByteCount < 4))
5263 rc = -EIO; /* bad smb */
5264 /* else if (pFindData){
5265 memcpy((char *) pFindData,
5266 (char *) &pSMBr->hdr.Protocol +
5267 data_offset, kl);
5268 }*/ else {
5269 /* check that length of list is not more than bcc */
5270 /* check that each entry does not go beyond length
5271 of list */
5272 /* check that each element of each entry does not
5273 go beyond end of list */
5274 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5275 struct fealist *ea_response_data;
5276 rc = 0;
5277 /* validate_trans2_offsets() */
5278 /* BB check if start of smb + data_offset > &bcc+ bcc */
5279 ea_response_data = (struct fealist *)
5280 (((char *) &pSMBr->hdr.Protocol) +
5281 data_offset);
5282 name_len = le32_to_cpu(ea_response_data->list_len);
5283 cFYI(1, ("ea length %d", name_len));
5284 if (name_len <= 8) {
5285 /* returned EA size zeroed at top of function */
5286 cFYI(1, ("empty EA list returned from server"));
5287 } else {
5288 /* account for ea list len */
5289 name_len -= 4;
5290 temp_fea = ea_response_data->list;
5291 temp_ptr = (char *)temp_fea;
5292 while (name_len > 0) {
5293 __u16 value_len;
5294 name_len -= 4;
5295 temp_ptr += 4;
5296 rc += temp_fea->name_len;
5297 /* account for prefix user. and trailing null */
5298 rc = rc + 5 + 1;
5299 if (rc < (int)buf_size) {
5300 memcpy(EAData, "user.", 5);
5301 EAData += 5;
5302 memcpy(EAData, temp_ptr,
5303 temp_fea->name_len);
5304 EAData += temp_fea->name_len;
5305 /* null terminate name */
5306 *EAData = 0;
5307 EAData = EAData + 1;
5308 } else if (buf_size == 0) {
5309 /* skip copy - calc size only */
5310 } else {
5311 /* stop before overrun buffer */
5312 rc = -ERANGE;
5313 break;
5315 name_len -= temp_fea->name_len;
5316 temp_ptr += temp_fea->name_len;
5317 /* account for trailing null */
5318 name_len--;
5319 temp_ptr++;
5320 value_len =
5321 le16_to_cpu(temp_fea->value_len);
5322 name_len -= value_len;
5323 temp_ptr += value_len;
5324 /* BB check that temp_ptr is still
5325 within the SMB BB*/
5327 /* no trailing null to account for
5328 in value len */
5329 /* go on to next EA */
5330 temp_fea = (struct fea *)temp_ptr;
5335 cifs_buf_release(pSMB);
5336 if (rc == -EAGAIN)
5337 goto QAllEAsRetry;
5339 return (ssize_t)rc;
5342 ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
5343 const unsigned char *searchName, const unsigned char *ea_name,
5344 unsigned char *ea_value, size_t buf_size,
5345 const struct nls_table *nls_codepage, int remap)
5347 TRANSACTION2_QPI_REQ *pSMB = NULL;
5348 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5349 int rc = 0;
5350 int bytes_returned;
5351 int name_len;
5352 struct fea *temp_fea;
5353 char *temp_ptr;
5354 __u16 params, byte_count;
5356 cFYI(1, ("In Query EA path %s", searchName));
5357 QEARetry:
5358 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5359 (void **) &pSMBr);
5360 if (rc)
5361 return rc;
5363 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5364 name_len =
5365 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5366 PATH_MAX, nls_codepage, remap);
5367 name_len++; /* trailing null */
5368 name_len *= 2;
5369 } else { /* BB improve the check for buffer overruns BB */
5370 name_len = strnlen(searchName, PATH_MAX);
5371 name_len++; /* trailing null */
5372 strncpy(pSMB->FileName, searchName, name_len);
5375 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5376 pSMB->TotalDataCount = 0;
5377 pSMB->MaxParameterCount = cpu_to_le16(2);
5378 /* BB find exact max SMB PDU from sess structure BB */
5379 pSMB->MaxDataCount = cpu_to_le16(4000);
5380 pSMB->MaxSetupCount = 0;
5381 pSMB->Reserved = 0;
5382 pSMB->Flags = 0;
5383 pSMB->Timeout = 0;
5384 pSMB->Reserved2 = 0;
5385 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5386 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5387 pSMB->DataCount = 0;
5388 pSMB->DataOffset = 0;
5389 pSMB->SetupCount = 1;
5390 pSMB->Reserved3 = 0;
5391 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5392 byte_count = params + 1 /* pad */ ;
5393 pSMB->TotalParameterCount = cpu_to_le16(params);
5394 pSMB->ParameterCount = pSMB->TotalParameterCount;
5395 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5396 pSMB->Reserved4 = 0;
5397 pSMB->hdr.smb_buf_length += byte_count;
5398 pSMB->ByteCount = cpu_to_le16(byte_count);
5400 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5401 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5402 if (rc) {
5403 cFYI(1, ("Send error in Query EA = %d", rc));
5404 } else { /* decode response */
5405 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5407 /* BB also check enough total bytes returned */
5408 /* BB we need to improve the validity checking
5409 of these trans2 responses */
5410 if (rc || (pSMBr->ByteCount < 4))
5411 rc = -EIO; /* bad smb */
5412 /* else if (pFindData){
5413 memcpy((char *) pFindData,
5414 (char *) &pSMBr->hdr.Protocol +
5415 data_offset, kl);
5416 }*/ else {
5417 /* check that length of list is not more than bcc */
5418 /* check that each entry does not go beyond length
5419 of list */
5420 /* check that each element of each entry does not
5421 go beyond end of list */
5422 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5423 struct fealist *ea_response_data;
5424 rc = -ENODATA;
5425 /* validate_trans2_offsets() */
5426 /* BB check if start of smb + data_offset > &bcc+ bcc*/
5427 ea_response_data = (struct fealist *)
5428 (((char *) &pSMBr->hdr.Protocol) +
5429 data_offset);
5430 name_len = le32_to_cpu(ea_response_data->list_len);
5431 cFYI(1, ("ea length %d", name_len));
5432 if (name_len <= 8) {
5433 /* returned EA size zeroed at top of function */
5434 cFYI(1, ("empty EA list returned from server"));
5435 } else {
5436 /* account for ea list len */
5437 name_len -= 4;
5438 temp_fea = ea_response_data->list;
5439 temp_ptr = (char *)temp_fea;
5440 /* loop through checking if we have a matching
5441 name and then return the associated value */
5442 while (name_len > 0) {
5443 __u16 value_len;
5444 name_len -= 4;
5445 temp_ptr += 4;
5446 value_len =
5447 le16_to_cpu(temp_fea->value_len);
5448 /* BB validate that value_len falls within SMB,
5449 even though maximum for name_len is 255 */
5450 if (memcmp(temp_fea->name, ea_name,
5451 temp_fea->name_len) == 0) {
5452 /* found a match */
5453 rc = value_len;
5454 /* account for prefix user. and trailing null */
5455 if (rc <= (int)buf_size) {
5456 memcpy(ea_value,
5457 temp_fea->name+temp_fea->name_len+1,
5458 rc);
5459 /* ea values, unlike ea
5460 names, are not null
5461 terminated */
5462 } else if (buf_size == 0) {
5463 /* skip copy - calc size only */
5464 } else {
5465 /* stop before overrun buffer */
5466 rc = -ERANGE;
5468 break;
5470 name_len -= temp_fea->name_len;
5471 temp_ptr += temp_fea->name_len;
5472 /* account for trailing null */
5473 name_len--;
5474 temp_ptr++;
5475 name_len -= value_len;
5476 temp_ptr += value_len;
5477 /* No trailing null to account for in
5478 value_len. Go on to next EA */
5479 temp_fea = (struct fea *)temp_ptr;
5484 cifs_buf_release(pSMB);
5485 if (rc == -EAGAIN)
5486 goto QEARetry;
5488 return (ssize_t)rc;
5492 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
5493 const char *ea_name, const void *ea_value,
5494 const __u16 ea_value_len, const struct nls_table *nls_codepage,
5495 int remap)
5497 struct smb_com_transaction2_spi_req *pSMB = NULL;
5498 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5499 struct fealist *parm_data;
5500 int name_len;
5501 int rc = 0;
5502 int bytes_returned = 0;
5503 __u16 params, param_offset, byte_count, offset, count;
5505 cFYI(1, ("In SetEA"));
5506 SetEARetry:
5507 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5508 (void **) &pSMBr);
5509 if (rc)
5510 return rc;
5512 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5513 name_len =
5514 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5515 PATH_MAX, nls_codepage, remap);
5516 name_len++; /* trailing null */
5517 name_len *= 2;
5518 } else { /* BB improve the check for buffer overruns BB */
5519 name_len = strnlen(fileName, PATH_MAX);
5520 name_len++; /* trailing null */
5521 strncpy(pSMB->FileName, fileName, name_len);
5524 params = 6 + name_len;
5526 /* done calculating parms using name_len of file name,
5527 now use name_len to calculate length of ea name
5528 we are going to create in the inode xattrs */
5529 if (ea_name == NULL)
5530 name_len = 0;
5531 else
5532 name_len = strnlen(ea_name, 255);
5534 count = sizeof(*parm_data) + ea_value_len + name_len;
5535 pSMB->MaxParameterCount = cpu_to_le16(2);
5536 /* BB find max SMB PDU from sess */
5537 pSMB->MaxDataCount = cpu_to_le16(1000);
5538 pSMB->MaxSetupCount = 0;
5539 pSMB->Reserved = 0;
5540 pSMB->Flags = 0;
5541 pSMB->Timeout = 0;
5542 pSMB->Reserved2 = 0;
5543 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5544 InformationLevel) - 4;
5545 offset = param_offset + params;
5546 pSMB->InformationLevel =
5547 cpu_to_le16(SMB_SET_FILE_EA);
5549 parm_data =
5550 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
5551 offset);
5552 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5553 pSMB->DataOffset = cpu_to_le16(offset);
5554 pSMB->SetupCount = 1;
5555 pSMB->Reserved3 = 0;
5556 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5557 byte_count = 3 /* pad */ + params + count;
5558 pSMB->DataCount = cpu_to_le16(count);
5559 parm_data->list_len = cpu_to_le32(count);
5560 parm_data->list[0].EA_flags = 0;
5561 /* we checked above that name len is less than 255 */
5562 parm_data->list[0].name_len = (__u8)name_len;
5563 /* EA names are always ASCII */
5564 if (ea_name)
5565 strncpy(parm_data->list[0].name, ea_name, name_len);
5566 parm_data->list[0].name[name_len] = 0;
5567 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
5568 /* caller ensures that ea_value_len is less than 64K but
5569 we need to ensure that it fits within the smb */
5571 /*BB add length check to see if it would fit in
5572 negotiated SMB buffer size BB */
5573 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5574 if (ea_value_len)
5575 memcpy(parm_data->list[0].name+name_len+1,
5576 ea_value, ea_value_len);
5578 pSMB->TotalDataCount = pSMB->DataCount;
5579 pSMB->ParameterCount = cpu_to_le16(params);
5580 pSMB->TotalParameterCount = pSMB->ParameterCount;
5581 pSMB->Reserved4 = 0;
5582 pSMB->hdr.smb_buf_length += byte_count;
5583 pSMB->ByteCount = cpu_to_le16(byte_count);
5584 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5585 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5586 if (rc)
5587 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
5589 cifs_buf_release(pSMB);
5591 if (rc == -EAGAIN)
5592 goto SetEARetry;
5594 return rc;
5597 #endif