projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branches 'spi/topic/mtk', 'spi/topic/pxa2xx', 'spi/topic/qspi...
[deliverable/linux.git] / fs / cifs / cifssmb.c
1 /*
2 * fs/cifs/cifssmb.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * Contains the routines for constructing the SMB PDUs themselves
8 *
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.
13 *
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.
18 *
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
22 */
23
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 */
29
30 #include <linux/fs.h>
31 #include <linux/kernel.h>
32 #include <linux/vfs.h>
33 #include <linux/slab.h>
34 #include <linux/posix_acl_xattr.h>
35 #include <linux/pagemap.h>
36 #include <linux/swap.h>
37 #include <linux/task_io_accounting_ops.h>
38 #include <asm/uaccess.h>
39 #include "cifspdu.h"
40 #include "cifsglob.h"
41 #include "cifsacl.h"
42 #include "cifsproto.h"
43 #include "cifs_unicode.h"
44 #include "cifs_debug.h"
45 #include "fscache.h"
46
47 #ifdef CONFIG_CIFS_POSIX
48 static struct {
49 int index;
50 char *name;
51 } protocols[] = {
52 #ifdef CONFIG_CIFS_WEAK_PW_HASH
53 {LANMAN_PROT, "\2LM1.2X002"},
54 {LANMAN2_PROT, "\2LANMAN2.1"},
55 #endif /* weak password hashing for legacy clients */
56 {CIFS_PROT, "\2NT LM 0.12"},
57 {POSIX_PROT, "\2POSIX 2"},
58 {BAD_PROT, "\2"}
59 };
60 #else
61 static struct {
62 int index;
63 char *name;
64 } protocols[] = {
65 #ifdef CONFIG_CIFS_WEAK_PW_HASH
66 {LANMAN_PROT, "\2LM1.2X002"},
67 {LANMAN2_PROT, "\2LANMAN2.1"},
68 #endif /* weak password hashing for legacy clients */
69 {CIFS_PROT, "\2NT LM 0.12"},
70 {BAD_PROT, "\2"}
71 };
72 #endif
73
74 /* define the number of elements in the cifs dialect array */
75 #ifdef CONFIG_CIFS_POSIX
76 #ifdef CONFIG_CIFS_WEAK_PW_HASH
77 #define CIFS_NUM_PROT 4
78 #else
79 #define CIFS_NUM_PROT 2
80 #endif /* CIFS_WEAK_PW_HASH */
81 #else /* not posix */
82 #ifdef CONFIG_CIFS_WEAK_PW_HASH
83 #define CIFS_NUM_PROT 3
84 #else
85 #define CIFS_NUM_PROT 1
86 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
87 #endif /* CIFS_POSIX */
88
89 /*
90 * Mark as invalid, all open files on tree connections since they
91 * were closed when session to server was lost.
92 */
93 void
94 cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
95 {
96 struct cifsFileInfo *open_file = NULL;
97 struct list_head *tmp;
98 struct list_head *tmp1;
99
100 /* list all files open on tree connection and mark them invalid */
101 spin_lock(&cifs_file_list_lock);
102 list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
103 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
104 open_file->invalidHandle = true;
105 open_file->oplock_break_cancelled = true;
106 }
107 spin_unlock(&cifs_file_list_lock);
108 /*
109 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
110 * to this tcon.
111 */
112 }
113
114 /* reconnect the socket, tcon, and smb session if needed */
115 static int
116 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
117 {
118 int rc;
119 struct cifs_ses *ses;
120 struct TCP_Server_Info *server;
121 struct nls_table *nls_codepage;
122
123 /*
124 * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
125 * tcp and smb session status done differently for those three - in the
126 * calling routine
127 */
128 if (!tcon)
129 return 0;
130
131 ses = tcon->ses;
132 server = ses->server;
133
134 /*
135 * only tree disconnect, open, and write, (and ulogoff which does not
136 * have tcon) are allowed as we start force umount
137 */
138 if (tcon->tidStatus == CifsExiting) {
139 if (smb_command != SMB_COM_WRITE_ANDX &&
140 smb_command != SMB_COM_OPEN_ANDX &&
141 smb_command != SMB_COM_TREE_DISCONNECT) {
142 cifs_dbg(FYI, "can not send cmd %d while umounting\n",
143 smb_command);
144 return -ENODEV;
145 }
146 }
147
148 /*
149 * Give demultiplex thread up to 10 seconds to reconnect, should be
150 * greater than cifs socket timeout which is 7 seconds
151 */
152 while (server->tcpStatus == CifsNeedReconnect) {
153 wait_event_interruptible_timeout(server->response_q,
154 (server->tcpStatus != CifsNeedReconnect), 10 * HZ);
155
156 /* are we still trying to reconnect? */
157 if (server->tcpStatus != CifsNeedReconnect)
158 break;
159
160 /*
161 * on "soft" mounts we wait once. Hard mounts keep
162 * retrying until process is killed or server comes
163 * back on-line
164 */
165 if (!tcon->retry) {
166 cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
167 return -EHOSTDOWN;
168 }
169 }
170
171 if (!ses->need_reconnect && !tcon->need_reconnect)
172 return 0;
173
174 nls_codepage = load_nls_default();
175
176 /*
177 * need to prevent multiple threads trying to simultaneously
178 * reconnect the same SMB session
179 */
180 mutex_lock(&ses->session_mutex);
181 rc = cifs_negotiate_protocol(0, ses);
182 if (rc == 0 && ses->need_reconnect)
183 rc = cifs_setup_session(0, ses, nls_codepage);
184
185 /* do we need to reconnect tcon? */
186 if (rc || !tcon->need_reconnect) {
187 mutex_unlock(&ses->session_mutex);
188 goto out;
189 }
190
191 cifs_mark_open_files_invalid(tcon);
192 rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
193 mutex_unlock(&ses->session_mutex);
194 cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc);
195
196 if (rc)
197 goto out;
198
199 atomic_inc(&tconInfoReconnectCount);
200
201 /* tell server Unix caps we support */
202 if (ses->capabilities & CAP_UNIX)
203 reset_cifs_unix_caps(0, tcon, NULL, NULL);
204
205 /*
206 * Removed call to reopen open files here. It is safer (and faster) to
207 * reopen files one at a time as needed in read and write.
208 *
209 * FIXME: what about file locks? don't we need to reclaim them ASAP?
210 */
211
212 out:
213 /*
214 * Check if handle based operation so we know whether we can continue
215 * or not without returning to caller to reset file handle
216 */
217 switch (smb_command) {
218 case SMB_COM_READ_ANDX:
219 case SMB_COM_WRITE_ANDX:
220 case SMB_COM_CLOSE:
221 case SMB_COM_FIND_CLOSE2:
222 case SMB_COM_LOCKING_ANDX:
223 rc = -EAGAIN;
224 }
225
226 unload_nls(nls_codepage);
227 return rc;
228 }
229
230 /* Allocate and return pointer to an SMB request buffer, and set basic
231 SMB information in the SMB header. If the return code is zero, this
232 function must have filled in request_buf pointer */
233 static int
234 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
235 void **request_buf)
236 {
237 int rc;
238
239 rc = cifs_reconnect_tcon(tcon, smb_command);
240 if (rc)
241 return rc;
242
243 *request_buf = cifs_small_buf_get();
244 if (*request_buf == NULL) {
245 /* BB should we add a retry in here if not a writepage? */
246 return -ENOMEM;
247 }
248
249 header_assemble((struct smb_hdr *) *request_buf, smb_command,
250 tcon, wct);
251
252 if (tcon != NULL)
253 cifs_stats_inc(&tcon->num_smbs_sent);
254
255 return 0;
256 }
257
258 int
259 small_smb_init_no_tc(const int smb_command, const int wct,
260 struct cifs_ses *ses, void **request_buf)
261 {
262 int rc;
263 struct smb_hdr *buffer;
264
265 rc = small_smb_init(smb_command, wct, NULL, request_buf);
266 if (rc)
267 return rc;
268
269 buffer = (struct smb_hdr *)*request_buf;
270 buffer->Mid = get_next_mid(ses->server);
271 if (ses->capabilities & CAP_UNICODE)
272 buffer->Flags2 |= SMBFLG2_UNICODE;
273 if (ses->capabilities & CAP_STATUS32)
274 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
275
276 /* uid, tid can stay at zero as set in header assemble */
277
278 /* BB add support for turning on the signing when
279 this function is used after 1st of session setup requests */
280
281 return rc;
282 }
283
284 /* If the return code is zero, this function must fill in request_buf pointer */
285 static int
286 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
287 void **request_buf, void **response_buf)
288 {
289 *request_buf = cifs_buf_get();
290 if (*request_buf == NULL) {
291 /* BB should we add a retry in here if not a writepage? */
292 return -ENOMEM;
293 }
294 /* Although the original thought was we needed the response buf for */
295 /* potential retries of smb operations it turns out we can determine */
296 /* from the mid flags when the request buffer can be resent without */
297 /* having to use a second distinct buffer for the response */
298 if (response_buf)
299 *response_buf = *request_buf;
300
301 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
302 wct);
303
304 if (tcon != NULL)
305 cifs_stats_inc(&tcon->num_smbs_sent);
306
307 return 0;
308 }
309
310 /* If the return code is zero, this function must fill in request_buf pointer */
311 static int
312 smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
313 void **request_buf, void **response_buf)
314 {
315 int rc;
316
317 rc = cifs_reconnect_tcon(tcon, smb_command);
318 if (rc)
319 return rc;
320
321 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
322 }
323
324 static int
325 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
326 void **request_buf, void **response_buf)
327 {
328 if (tcon->ses->need_reconnect || tcon->need_reconnect)
329 return -EHOSTDOWN;
330
331 return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
332 }
333
334 static int validate_t2(struct smb_t2_rsp *pSMB)
335 {
336 unsigned int total_size;
337
338 /* check for plausible wct */
339 if (pSMB->hdr.WordCount < 10)
340 goto vt2_err;
341
342 /* check for parm and data offset going beyond end of smb */
343 if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
344 get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
345 goto vt2_err;
346
347 total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
348 if (total_size >= 512)
349 goto vt2_err;
350
351 /* check that bcc is at least as big as parms + data, and that it is
352 * less than negotiated smb buffer
353 */
354 total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
355 if (total_size > get_bcc(&pSMB->hdr) ||
356 total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
357 goto vt2_err;
358
359 return 0;
360 vt2_err:
361 cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
362 sizeof(struct smb_t2_rsp) + 16);
363 return -EINVAL;
364 }
365
366 static int
367 decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
368 {
369 int rc = 0;
370 u16 count;
371 char *guid = pSMBr->u.extended_response.GUID;
372 struct TCP_Server_Info *server = ses->server;
373
374 count = get_bcc(&pSMBr->hdr);
375 if (count < SMB1_CLIENT_GUID_SIZE)
376 return -EIO;
377
378 spin_lock(&cifs_tcp_ses_lock);
379 if (server->srv_count > 1) {
380 spin_unlock(&cifs_tcp_ses_lock);
381 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
382 cifs_dbg(FYI, "server UID changed\n");
383 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
384 }
385 } else {
386 spin_unlock(&cifs_tcp_ses_lock);
387 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
388 }
389
390 if (count == SMB1_CLIENT_GUID_SIZE) {
391 server->sec_ntlmssp = true;
392 } else {
393 count -= SMB1_CLIENT_GUID_SIZE;
394 rc = decode_negTokenInit(
395 pSMBr->u.extended_response.SecurityBlob, count, server);
396 if (rc != 1)
397 return -EINVAL;
398 }
399
400 return 0;
401 }
402
403 int
404 cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
405 {
406 bool srv_sign_required = server->sec_mode & server->vals->signing_required;
407 bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
408 bool mnt_sign_enabled = global_secflags & CIFSSEC_MAY_SIGN;
409
410 /*
411 * Is signing required by mnt options? If not then check
412 * global_secflags to see if it is there.
413 */
414 if (!mnt_sign_required)
415 mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
416 CIFSSEC_MUST_SIGN);
417
418 /*
419 * If signing is required then it's automatically enabled too,
420 * otherwise, check to see if the secflags allow it.
421 */
422 mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
423 (global_secflags & CIFSSEC_MAY_SIGN);
424
425 /* If server requires signing, does client allow it? */
426 if (srv_sign_required) {
427 if (!mnt_sign_enabled) {
428 cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!");
429 return -ENOTSUPP;
430 }
431 server->sign = true;
432 }
433
434 /* If client requires signing, does server allow it? */
435 if (mnt_sign_required) {
436 if (!srv_sign_enabled) {
437 cifs_dbg(VFS, "Server does not support signing!");
438 return -ENOTSUPP;
439 }
440 server->sign = true;
441 }
442
443 return 0;
444 }
445
446 #ifdef CONFIG_CIFS_WEAK_PW_HASH
447 static int
448 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
449 {
450 __s16 tmp;
451 struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
452
453 if (server->dialect != LANMAN_PROT && server->dialect != LANMAN2_PROT)
454 return -EOPNOTSUPP;
455
456 server->sec_mode = le16_to_cpu(rsp->SecurityMode);
457 server->maxReq = min_t(unsigned int,
458 le16_to_cpu(rsp->MaxMpxCount),
459 cifs_max_pending);
460 set_credits(server, server->maxReq);
461 server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
462 /* even though we do not use raw we might as well set this
463 accurately, in case we ever find a need for it */
464 if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
465 server->max_rw = 0xFF00;
466 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
467 } else {
468 server->max_rw = 0;/* do not need to use raw anyway */
469 server->capabilities = CAP_MPX_MODE;
470 }
471 tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
472 if (tmp == -1) {
473 /* OS/2 often does not set timezone therefore
474 * we must use server time to calc time zone.
475 * Could deviate slightly from the right zone.
476 * Smallest defined timezone difference is 15 minutes
477 * (i.e. Nepal). Rounding up/down is done to match
478 * this requirement.
479 */
480 int val, seconds, remain, result;
481 struct timespec ts, utc;
482 utc = CURRENT_TIME;
483 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
484 rsp->SrvTime.Time, 0);
485 cifs_dbg(FYI, "SrvTime %d sec since 1970 (utc: %d) diff: %d\n",
486 (int)ts.tv_sec, (int)utc.tv_sec,
487 (int)(utc.tv_sec - ts.tv_sec));
488 val = (int)(utc.tv_sec - ts.tv_sec);
489 seconds = abs(val);
490 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
491 remain = seconds % MIN_TZ_ADJ;
492 if (remain >= (MIN_TZ_ADJ / 2))
493 result += MIN_TZ_ADJ;
494 if (val < 0)
495 result = -result;
496 server->timeAdj = result;
497 } else {
498 server->timeAdj = (int)tmp;
499 server->timeAdj *= 60; /* also in seconds */
500 }
501 cifs_dbg(FYI, "server->timeAdj: %d seconds\n", server->timeAdj);
502
503
504 /* BB get server time for time conversions and add
505 code to use it and timezone since this is not UTC */
506
507 if (rsp->EncryptionKeyLength ==
508 cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
509 memcpy(server->cryptkey, rsp->EncryptionKey,
510 CIFS_CRYPTO_KEY_SIZE);
511 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
512 return -EIO; /* need cryptkey unless plain text */
513 }
514
515 cifs_dbg(FYI, "LANMAN negotiated\n");
516 return 0;
517 }
518 #else
519 static inline int
520 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
521 {
522 cifs_dbg(VFS, "mount failed, cifs module not built with CIFS_WEAK_PW_HASH support\n");
523 return -EOPNOTSUPP;
524 }
525 #endif
526
527 static bool
528 should_set_ext_sec_flag(enum securityEnum sectype)
529 {
530 switch (sectype) {
531 case RawNTLMSSP:
532 case Kerberos:
533 return true;
534 case Unspecified:
535 if (global_secflags &
536 (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP))
537 return true;
538 /* Fallthrough */
539 default:
540 return false;
541 }
542 }
543
544 int
545 CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
546 {
547 NEGOTIATE_REQ *pSMB;
548 NEGOTIATE_RSP *pSMBr;
549 int rc = 0;
550 int bytes_returned;
551 int i;
552 struct TCP_Server_Info *server = ses->server;
553 u16 count;
554
555 if (!server) {
556 WARN(1, "%s: server is NULL!\n", __func__);
557 return -EIO;
558 }
559
560 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
561 (void **) &pSMB, (void **) &pSMBr);
562 if (rc)
563 return rc;
564
565 pSMB->hdr.Mid = get_next_mid(server);
566 pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
567
568 if (should_set_ext_sec_flag(ses->sectype)) {
569 cifs_dbg(FYI, "Requesting extended security.");
570 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
571 }
572
573 count = 0;
574 for (i = 0; i < CIFS_NUM_PROT; i++) {
575 strncpy(pSMB->DialectsArray+count, protocols[i].name, 16);
576 count += strlen(protocols[i].name) + 1;
577 /* null at end of source and target buffers anyway */
578 }
579 inc_rfc1001_len(pSMB, count);
580 pSMB->ByteCount = cpu_to_le16(count);
581
582 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
583 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
584 if (rc != 0)
585 goto neg_err_exit;
586
587 server->dialect = le16_to_cpu(pSMBr->DialectIndex);
588 cifs_dbg(FYI, "Dialect: %d\n", server->dialect);
589 /* Check wct = 1 error case */
590 if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
591 /* core returns wct = 1, but we do not ask for core - otherwise
592 small wct just comes when dialect index is -1 indicating we
593 could not negotiate a common dialect */
594 rc = -EOPNOTSUPP;
595 goto neg_err_exit;
596 } else if (pSMBr->hdr.WordCount == 13) {
597 server->negflavor = CIFS_NEGFLAVOR_LANMAN;
598 rc = decode_lanman_negprot_rsp(server, pSMBr);
599 goto signing_check;
600 } else if (pSMBr->hdr.WordCount != 17) {
601 /* unknown wct */
602 rc = -EOPNOTSUPP;
603 goto neg_err_exit;
604 }
605 /* else wct == 17, NTLM or better */
606
607 server->sec_mode = pSMBr->SecurityMode;
608 if ((server->sec_mode & SECMODE_USER) == 0)
609 cifs_dbg(FYI, "share mode security\n");
610
611 /* one byte, so no need to convert this or EncryptionKeyLen from
612 little endian */
613 server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
614 cifs_max_pending);
615 set_credits(server, server->maxReq);
616 /* probably no need to store and check maxvcs */
617 server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
618 server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
619 cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
620 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
621 server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
622 server->timeAdj *= 60;
623
624 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
625 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
626 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
627 CIFS_CRYPTO_KEY_SIZE);
628 } else if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
629 server->capabilities & CAP_EXTENDED_SECURITY) {
630 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
631 rc = decode_ext_sec_blob(ses, pSMBr);
632 } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
633 rc = -EIO; /* no crypt key only if plain text pwd */
634 } else {
635 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
636 server->capabilities &= ~CAP_EXTENDED_SECURITY;
637 }
638
639 signing_check:
640 if (!rc)
641 rc = cifs_enable_signing(server, ses->sign);
642 neg_err_exit:
643 cifs_buf_release(pSMB);
644
645 cifs_dbg(FYI, "negprot rc %d\n", rc);
646 return rc;
647 }
648
649 int
650 CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
651 {
652 struct smb_hdr *smb_buffer;
653 int rc = 0;
654
655 cifs_dbg(FYI, "In tree disconnect\n");
656
657 /* BB: do we need to check this? These should never be NULL. */
658 if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
659 return -EIO;
660
661 /*
662 * No need to return error on this operation if tid invalidated and
663 * closed on server already e.g. due to tcp session crashing. Also,
664 * the tcon is no longer on the list, so no need to take lock before
665 * checking this.
666 */
667 if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
668 return 0;
669
670 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
671 (void **)&smb_buffer);
672 if (rc)
673 return rc;
674
675 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
676 if (rc)
677 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc);
678
679 /* No need to return error on this operation if tid invalidated and
680 closed on server already e.g. due to tcp session crashing */
681 if (rc == -EAGAIN)
682 rc = 0;
683
684 return rc;
685 }
686
687 /*
688 * This is a no-op for now. We're not really interested in the reply, but
689 * rather in the fact that the server sent one and that server->lstrp
690 * gets updated.
691 *
692 * FIXME: maybe we should consider checking that the reply matches request?
693 */
694 static void
695 cifs_echo_callback(struct mid_q_entry *mid)
696 {
697 struct TCP_Server_Info *server = mid->callback_data;
698
699 DeleteMidQEntry(mid);
700 add_credits(server, 1, CIFS_ECHO_OP);
701 }
702
703 int
704 CIFSSMBEcho(struct TCP_Server_Info *server)
705 {
706 ECHO_REQ *smb;
707 int rc = 0;
708 struct kvec iov;
709 struct smb_rqst rqst = { .rq_iov = &iov,
710 .rq_nvec = 1 };
711
712 cifs_dbg(FYI, "In echo request\n");
713
714 rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
715 if (rc)
716 return rc;
717
718 /* set up echo request */
719 smb->hdr.Tid = 0xffff;
720 smb->hdr.WordCount = 1;
721 put_unaligned_le16(1, &smb->EchoCount);
722 put_bcc(1, &smb->hdr);
723 smb->Data[0] = 'a';
724 inc_rfc1001_len(smb, 3);
725 iov.iov_base = smb;
726 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
727
728 rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback,
729 server, CIFS_ASYNC_OP | CIFS_ECHO_OP);
730 if (rc)
731 cifs_dbg(FYI, "Echo request failed: %d\n", rc);
732
733 cifs_small_buf_release(smb);
734
735 return rc;
736 }
737
738 int
739 CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
740 {
741 LOGOFF_ANDX_REQ *pSMB;
742 int rc = 0;
743
744 cifs_dbg(FYI, "In SMBLogoff for session disconnect\n");
745
746 /*
747 * BB: do we need to check validity of ses and server? They should
748 * always be valid since we have an active reference. If not, that
749 * should probably be a BUG()
750 */
751 if (!ses || !ses->server)
752 return -EIO;
753
754 mutex_lock(&ses->session_mutex);
755 if (ses->need_reconnect)
756 goto session_already_dead; /* no need to send SMBlogoff if uid
757 already closed due to reconnect */
758 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
759 if (rc) {
760 mutex_unlock(&ses->session_mutex);
761 return rc;
762 }
763
764 pSMB->hdr.Mid = get_next_mid(ses->server);
765
766 if (ses->server->sign)
767 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
768
769 pSMB->hdr.Uid = ses->Suid;
770
771 pSMB->AndXCommand = 0xFF;
772 rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
773 session_already_dead:
774 mutex_unlock(&ses->session_mutex);
775
776 /* if session dead then we do not need to do ulogoff,
777 since server closed smb session, no sense reporting
778 error */
779 if (rc == -EAGAIN)
780 rc = 0;
781 return rc;
782 }
783
784 int
785 CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
786 const char *fileName, __u16 type,
787 const struct nls_table *nls_codepage, int remap)
788 {
789 TRANSACTION2_SPI_REQ *pSMB = NULL;
790 TRANSACTION2_SPI_RSP *pSMBr = NULL;
791 struct unlink_psx_rq *pRqD;
792 int name_len;
793 int rc = 0;
794 int bytes_returned = 0;
795 __u16 params, param_offset, offset, byte_count;
796
797 cifs_dbg(FYI, "In POSIX delete\n");
798 PsxDelete:
799 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
800 (void **) &pSMBr);
801 if (rc)
802 return rc;
803
804 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
805 name_len =
806 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
807 PATH_MAX, nls_codepage, remap);
808 name_len++; /* trailing null */
809 name_len *= 2;
810 } else { /* BB add path length overrun check */
811 name_len = strnlen(fileName, PATH_MAX);
812 name_len++; /* trailing null */
813 strncpy(pSMB->FileName, fileName, name_len);
814 }
815
816 params = 6 + name_len;
817 pSMB->MaxParameterCount = cpu_to_le16(2);
818 pSMB->MaxDataCount = 0; /* BB double check this with jra */
819 pSMB->MaxSetupCount = 0;
820 pSMB->Reserved = 0;
821 pSMB->Flags = 0;
822 pSMB->Timeout = 0;
823 pSMB->Reserved2 = 0;
824 param_offset = offsetof(struct smb_com_transaction2_spi_req,
825 InformationLevel) - 4;
826 offset = param_offset + params;
827
828 /* Setup pointer to Request Data (inode type) */
829 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
830 pRqD->type = cpu_to_le16(type);
831 pSMB->ParameterOffset = cpu_to_le16(param_offset);
832 pSMB->DataOffset = cpu_to_le16(offset);
833 pSMB->SetupCount = 1;
834 pSMB->Reserved3 = 0;
835 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
836 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
837
838 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
839 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
840 pSMB->ParameterCount = cpu_to_le16(params);
841 pSMB->TotalParameterCount = pSMB->ParameterCount;
842 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
843 pSMB->Reserved4 = 0;
844 inc_rfc1001_len(pSMB, byte_count);
845 pSMB->ByteCount = cpu_to_le16(byte_count);
846 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
847 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
848 if (rc)
849 cifs_dbg(FYI, "Posix delete returned %d\n", rc);
850 cifs_buf_release(pSMB);
851
852 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
853
854 if (rc == -EAGAIN)
855 goto PsxDelete;
856
857 return rc;
858 }
859
860 int
861 CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
862 struct cifs_sb_info *cifs_sb)
863 {
864 DELETE_FILE_REQ *pSMB = NULL;
865 DELETE_FILE_RSP *pSMBr = NULL;
866 int rc = 0;
867 int bytes_returned;
868 int name_len;
869 int remap = cifs_remap(cifs_sb);
870
871 DelFileRetry:
872 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
873 (void **) &pSMBr);
874 if (rc)
875 return rc;
876
877 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
878 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
879 PATH_MAX, cifs_sb->local_nls,
880 remap);
881 name_len++; /* trailing null */
882 name_len *= 2;
883 } else { /* BB improve check for buffer overruns BB */
884 name_len = strnlen(name, PATH_MAX);
885 name_len++; /* trailing null */
886 strncpy(pSMB->fileName, name, name_len);
887 }
888 pSMB->SearchAttributes =
889 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
890 pSMB->BufferFormat = 0x04;
891 inc_rfc1001_len(pSMB, name_len + 1);
892 pSMB->ByteCount = cpu_to_le16(name_len + 1);
893 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
894 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
895 cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
896 if (rc)
897 cifs_dbg(FYI, "Error in RMFile = %d\n", rc);
898
899 cifs_buf_release(pSMB);
900 if (rc == -EAGAIN)
901 goto DelFileRetry;
902
903 return rc;
904 }
905
906 int
907 CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
908 struct cifs_sb_info *cifs_sb)
909 {
910 DELETE_DIRECTORY_REQ *pSMB = NULL;
911 DELETE_DIRECTORY_RSP *pSMBr = NULL;
912 int rc = 0;
913 int bytes_returned;
914 int name_len;
915 int remap = cifs_remap(cifs_sb);
916
917 cifs_dbg(FYI, "In CIFSSMBRmDir\n");
918 RmDirRetry:
919 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
920 (void **) &pSMBr);
921 if (rc)
922 return rc;
923
924 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
925 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
926 PATH_MAX, cifs_sb->local_nls,
927 remap);
928 name_len++; /* trailing null */
929 name_len *= 2;
930 } else { /* BB improve check for buffer overruns BB */
931 name_len = strnlen(name, PATH_MAX);
932 name_len++; /* trailing null */
933 strncpy(pSMB->DirName, name, name_len);
934 }
935
936 pSMB->BufferFormat = 0x04;
937 inc_rfc1001_len(pSMB, name_len + 1);
938 pSMB->ByteCount = cpu_to_le16(name_len + 1);
939 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
940 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
941 cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
942 if (rc)
943 cifs_dbg(FYI, "Error in RMDir = %d\n", rc);
944
945 cifs_buf_release(pSMB);
946 if (rc == -EAGAIN)
947 goto RmDirRetry;
948 return rc;
949 }
950
951 int
952 CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
953 struct cifs_sb_info *cifs_sb)
954 {
955 int rc = 0;
956 CREATE_DIRECTORY_REQ *pSMB = NULL;
957 CREATE_DIRECTORY_RSP *pSMBr = NULL;
958 int bytes_returned;
959 int name_len;
960 int remap = cifs_remap(cifs_sb);
961
962 cifs_dbg(FYI, "In CIFSSMBMkDir\n");
963 MkDirRetry:
964 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
965 (void **) &pSMBr);
966 if (rc)
967 return rc;
968
969 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
970 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
971 PATH_MAX, cifs_sb->local_nls,
972 remap);
973 name_len++; /* trailing null */
974 name_len *= 2;
975 } else { /* BB improve check for buffer overruns BB */
976 name_len = strnlen(name, PATH_MAX);
977 name_len++; /* trailing null */
978 strncpy(pSMB->DirName, name, name_len);
979 }
980
981 pSMB->BufferFormat = 0x04;
982 inc_rfc1001_len(pSMB, name_len + 1);
983 pSMB->ByteCount = cpu_to_le16(name_len + 1);
984 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
985 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
986 cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
987 if (rc)
988 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc);
989
990 cifs_buf_release(pSMB);
991 if (rc == -EAGAIN)
992 goto MkDirRetry;
993 return rc;
994 }
995
996 int
997 CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
998 __u32 posix_flags, __u64 mode, __u16 *netfid,
999 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
1000 const char *name, const struct nls_table *nls_codepage,
1001 int remap)
1002 {
1003 TRANSACTION2_SPI_REQ *pSMB = NULL;
1004 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1005 int name_len;
1006 int rc = 0;
1007 int bytes_returned = 0;
1008 __u16 params, param_offset, offset, byte_count, count;
1009 OPEN_PSX_REQ *pdata;
1010 OPEN_PSX_RSP *psx_rsp;
1011
1012 cifs_dbg(FYI, "In POSIX Create\n");
1013 PsxCreat:
1014 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1015 (void **) &pSMBr);
1016 if (rc)
1017 return rc;
1018
1019 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1020 name_len =
1021 cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1022 PATH_MAX, nls_codepage, remap);
1023 name_len++; /* trailing null */
1024 name_len *= 2;
1025 } else { /* BB improve the check for buffer overruns BB */
1026 name_len = strnlen(name, PATH_MAX);
1027 name_len++; /* trailing null */
1028 strncpy(pSMB->FileName, name, name_len);
1029 }
1030
1031 params = 6 + name_len;
1032 count = sizeof(OPEN_PSX_REQ);
1033 pSMB->MaxParameterCount = cpu_to_le16(2);
1034 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1035 pSMB->MaxSetupCount = 0;
1036 pSMB->Reserved = 0;
1037 pSMB->Flags = 0;
1038 pSMB->Timeout = 0;
1039 pSMB->Reserved2 = 0;
1040 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1041 InformationLevel) - 4;
1042 offset = param_offset + params;
1043 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1044 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1045 pdata->Permissions = cpu_to_le64(mode);
1046 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1047 pdata->OpenFlags = cpu_to_le32(*pOplock);
1048 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1049 pSMB->DataOffset = cpu_to_le16(offset);
1050 pSMB->SetupCount = 1;
1051 pSMB->Reserved3 = 0;
1052 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1053 byte_count = 3 /* pad */ + params + count;
1054
1055 pSMB->DataCount = cpu_to_le16(count);
1056 pSMB->ParameterCount = cpu_to_le16(params);
1057 pSMB->TotalDataCount = pSMB->DataCount;
1058 pSMB->TotalParameterCount = pSMB->ParameterCount;
1059 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1060 pSMB->Reserved4 = 0;
1061 inc_rfc1001_len(pSMB, byte_count);
1062 pSMB->ByteCount = cpu_to_le16(byte_count);
1063 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1064 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1065 if (rc) {
1066 cifs_dbg(FYI, "Posix create returned %d\n", rc);
1067 goto psx_create_err;
1068 }
1069
1070 cifs_dbg(FYI, "copying inode info\n");
1071 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1072
1073 if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
1074 rc = -EIO; /* bad smb */
1075 goto psx_create_err;
1076 }
1077
1078 /* copy return information to pRetData */
1079 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1080 + le16_to_cpu(pSMBr->t2.DataOffset));
1081
1082 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1083 if (netfid)
1084 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1085 /* Let caller know file was created so we can set the mode. */
1086 /* Do we care about the CreateAction in any other cases? */
1087 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1088 *pOplock |= CIFS_CREATE_ACTION;
1089 /* check to make sure response data is there */
1090 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1091 pRetData->Type = cpu_to_le32(-1); /* unknown */
1092 cifs_dbg(NOISY, "unknown type\n");
1093 } else {
1094 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
1095 + sizeof(FILE_UNIX_BASIC_INFO)) {
1096 cifs_dbg(VFS, "Open response data too small\n");
1097 pRetData->Type = cpu_to_le32(-1);
1098 goto psx_create_err;
1099 }
1100 memcpy((char *) pRetData,
1101 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1102 sizeof(FILE_UNIX_BASIC_INFO));
1103 }
1104
1105 psx_create_err:
1106 cifs_buf_release(pSMB);
1107
1108 if (posix_flags & SMB_O_DIRECTORY)
1109 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
1110 else
1111 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
1112
1113 if (rc == -EAGAIN)
1114 goto PsxCreat;
1115
1116 return rc;
1117 }
1118
1119 static __u16 convert_disposition(int disposition)
1120 {
1121 __u16 ofun = 0;
1122
1123 switch (disposition) {
1124 case FILE_SUPERSEDE:
1125 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1126 break;
1127 case FILE_OPEN:
1128 ofun = SMBOPEN_OAPPEND;
1129 break;
1130 case FILE_CREATE:
1131 ofun = SMBOPEN_OCREATE;
1132 break;
1133 case FILE_OPEN_IF:
1134 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1135 break;
1136 case FILE_OVERWRITE:
1137 ofun = SMBOPEN_OTRUNC;
1138 break;
1139 case FILE_OVERWRITE_IF:
1140 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1141 break;
1142 default:
1143 cifs_dbg(FYI, "unknown disposition %d\n", disposition);
1144 ofun = SMBOPEN_OAPPEND; /* regular open */
1145 }
1146 return ofun;
1147 }
1148
1149 static int
1150 access_flags_to_smbopen_mode(const int access_flags)
1151 {
1152 int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1153
1154 if (masked_flags == GENERIC_READ)
1155 return SMBOPEN_READ;
1156 else if (masked_flags == GENERIC_WRITE)
1157 return SMBOPEN_WRITE;
1158
1159 /* just go for read/write */
1160 return SMBOPEN_READWRITE;
1161 }
1162
1163 int
1164 SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
1165 const char *fileName, const int openDisposition,
1166 const int access_flags, const int create_options, __u16 *netfid,
1167 int *pOplock, FILE_ALL_INFO *pfile_info,
1168 const struct nls_table *nls_codepage, int remap)
1169 {
1170 int rc = -EACCES;
1171 OPENX_REQ *pSMB = NULL;
1172 OPENX_RSP *pSMBr = NULL;
1173 int bytes_returned;
1174 int name_len;
1175 __u16 count;
1176
1177 OldOpenRetry:
1178 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1179 (void **) &pSMBr);
1180 if (rc)
1181 return rc;
1182
1183 pSMB->AndXCommand = 0xFF; /* none */
1184
1185 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1186 count = 1; /* account for one byte pad to word boundary */
1187 name_len =
1188 cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1189 fileName, PATH_MAX, nls_codepage, remap);
1190 name_len++; /* trailing null */
1191 name_len *= 2;
1192 } else { /* BB improve check for buffer overruns BB */
1193 count = 0; /* no pad */
1194 name_len = strnlen(fileName, PATH_MAX);
1195 name_len++; /* trailing null */
1196 strncpy(pSMB->fileName, fileName, name_len);
1197 }
1198 if (*pOplock & REQ_OPLOCK)
1199 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1200 else if (*pOplock & REQ_BATCHOPLOCK)
1201 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1202
1203 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1204 pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1205 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1206 /* set file as system file if special file such
1207 as fifo and server expecting SFU style and
1208 no Unix extensions */
1209
1210 if (create_options & CREATE_OPTION_SPECIAL)
1211 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1212 else /* BB FIXME BB */
1213 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1214
1215 if (create_options & CREATE_OPTION_READONLY)
1216 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1217
1218 /* BB FIXME BB */
1219 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1220 CREATE_OPTIONS_MASK); */
1221 /* BB FIXME END BB */
1222
1223 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1224 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1225 count += name_len;
1226 inc_rfc1001_len(pSMB, count);
1227
1228 pSMB->ByteCount = cpu_to_le16(count);
1229 /* long_op set to 1 to allow for oplock break timeouts */
1230 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1231 (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1232 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1233 if (rc) {
1234 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1235 } else {
1236 /* BB verify if wct == 15 */
1237
1238 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1239
1240 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1241 /* Let caller know file was created so we can set the mode. */
1242 /* Do we care about the CreateAction in any other cases? */
1243 /* BB FIXME BB */
1244 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1245 *pOplock |= CIFS_CREATE_ACTION; */
1246 /* BB FIXME END */
1247
1248 if (pfile_info) {
1249 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1250 pfile_info->LastAccessTime = 0; /* BB fixme */
1251 pfile_info->LastWriteTime = 0; /* BB fixme */
1252 pfile_info->ChangeTime = 0; /* BB fixme */
1253 pfile_info->Attributes =
1254 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1255 /* the file_info buf is endian converted by caller */
1256 pfile_info->AllocationSize =
1257 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1258 pfile_info->EndOfFile = pfile_info->AllocationSize;
1259 pfile_info->NumberOfLinks = cpu_to_le32(1);
1260 pfile_info->DeletePending = 0;
1261 }
1262 }
1263
1264 cifs_buf_release(pSMB);
1265 if (rc == -EAGAIN)
1266 goto OldOpenRetry;
1267 return rc;
1268 }
1269
1270 int
1271 CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,
1272 FILE_ALL_INFO *buf)
1273 {
1274 int rc = -EACCES;
1275 OPEN_REQ *req = NULL;
1276 OPEN_RSP *rsp = NULL;
1277 int bytes_returned;
1278 int name_len;
1279 __u16 count;
1280 struct cifs_sb_info *cifs_sb = oparms->cifs_sb;
1281 struct cifs_tcon *tcon = oparms->tcon;
1282 int remap = cifs_remap(cifs_sb);
1283 const struct nls_table *nls = cifs_sb->local_nls;
1284 int create_options = oparms->create_options;
1285 int desired_access = oparms->desired_access;
1286 int disposition = oparms->disposition;
1287 const char *path = oparms->path;
1288
1289 openRetry:
1290 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **)&req,
1291 (void **)&rsp);
1292 if (rc)
1293 return rc;
1294
1295 /* no commands go after this */
1296 req->AndXCommand = 0xFF;
1297
1298 if (req->hdr.Flags2 & SMBFLG2_UNICODE) {
1299 /* account for one byte pad to word boundary */
1300 count = 1;
1301 name_len = cifsConvertToUTF16((__le16 *)(req->fileName + 1),
1302 path, PATH_MAX, nls, remap);
1303 /* trailing null */
1304 name_len++;
1305 name_len *= 2;
1306 req->NameLength = cpu_to_le16(name_len);
1307 } else {
1308 /* BB improve check for buffer overruns BB */
1309 /* no pad */
1310 count = 0;
1311 name_len = strnlen(path, PATH_MAX);
1312 /* trailing null */
1313 name_len++;
1314 req->NameLength = cpu_to_le16(name_len);
1315 strncpy(req->fileName, path, name_len);
1316 }
1317
1318 if (*oplock & REQ_OPLOCK)
1319 req->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1320 else if (*oplock & REQ_BATCHOPLOCK)
1321 req->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1322
1323 req->DesiredAccess = cpu_to_le32(desired_access);
1324 req->AllocationSize = 0;
1325
1326 /*
1327 * Set file as system file if special file such as fifo and server
1328 * expecting SFU style and no Unix extensions.
1329 */
1330 if (create_options & CREATE_OPTION_SPECIAL)
1331 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1332 else
1333 req->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1334
1335 /*
1336 * XP does not handle ATTR_POSIX_SEMANTICS but it helps speed up case
1337 * sensitive checks for other servers such as Samba.
1338 */
1339 if (tcon->ses->capabilities & CAP_UNIX)
1340 req->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1341
1342 if (create_options & CREATE_OPTION_READONLY)
1343 req->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1344
1345 req->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1346 req->CreateDisposition = cpu_to_le32(disposition);
1347 req->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1348
1349 /* BB Expirement with various impersonation levels and verify */
1350 req->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1351 req->SecurityFlags = SECURITY_CONTEXT_TRACKING|SECURITY_EFFECTIVE_ONLY;
1352
1353 count += name_len;
1354 inc_rfc1001_len(req, count);
1355
1356 req->ByteCount = cpu_to_le16(count);
1357 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)req,
1358 (struct smb_hdr *)rsp, &bytes_returned, 0);
1359 cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1360 if (rc) {
1361 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1362 cifs_buf_release(req);
1363 if (rc == -EAGAIN)
1364 goto openRetry;
1365 return rc;
1366 }
1367
1368 /* 1 byte no need to le_to_cpu */
1369 *oplock = rsp->OplockLevel;
1370 /* cifs fid stays in le */
1371 oparms->fid->netfid = rsp->Fid;
1372
1373 /* Let caller know file was created so we can set the mode. */
1374 /* Do we care about the CreateAction in any other cases? */
1375 if (cpu_to_le32(FILE_CREATE) == rsp->CreateAction)
1376 *oplock |= CIFS_CREATE_ACTION;
1377
1378 if (buf) {
1379 /* copy from CreationTime to Attributes */
1380 memcpy((char *)buf, (char *)&rsp->CreationTime, 36);
1381 /* the file_info buf is endian converted by caller */
1382 buf->AllocationSize = rsp->AllocationSize;
1383 buf->EndOfFile = rsp->EndOfFile;
1384 buf->NumberOfLinks = cpu_to_le32(1);
1385 buf->DeletePending = 0;
1386 }
1387
1388 cifs_buf_release(req);
1389 return rc;
1390 }
1391
1392 /*
1393 * Discard any remaining data in the current SMB. To do this, we borrow the
1394 * current bigbuf.
1395 */
1396 static int
1397 cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1398 {
1399 unsigned int rfclen = get_rfc1002_length(server->smallbuf);
1400 int remaining = rfclen + 4 - server->total_read;
1401 struct cifs_readdata *rdata = mid->callback_data;
1402
1403 while (remaining > 0) {
1404 int length;
1405
1406 length = cifs_read_from_socket(server, server->bigbuf,
1407 min_t(unsigned int, remaining,
1408 CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
1409 if (length < 0)
1410 return length;
1411 server->total_read += length;
1412 remaining -= length;
1413 }
1414
1415 dequeue_mid(mid, rdata->result);
1416 return 0;
1417 }
1418
1419 int
1420 cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1421 {
1422 int length, len;
1423 unsigned int data_offset, data_len;
1424 struct cifs_readdata *rdata = mid->callback_data;
1425 char *buf = server->smallbuf;
1426 unsigned int buflen = get_rfc1002_length(buf) + 4;
1427
1428 cifs_dbg(FYI, "%s: mid=%llu offset=%llu bytes=%u\n",
1429 __func__, mid->mid, rdata->offset, rdata->bytes);
1430
1431 /*
1432 * read the rest of READ_RSP header (sans Data array), or whatever we
1433 * can if there's not enough data. At this point, we've read down to
1434 * the Mid.
1435 */
1436 len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
1437 HEADER_SIZE(server) + 1;
1438
1439 rdata->iov.iov_base = buf + HEADER_SIZE(server) - 1;
1440 rdata->iov.iov_len = len;
1441
1442 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
1443 if (length < 0)
1444 return length;
1445 server->total_read += length;
1446
1447 /* Was the SMB read successful? */
1448 rdata->result = server->ops->map_error(buf, false);
1449 if (rdata->result != 0) {
1450 cifs_dbg(FYI, "%s: server returned error %d\n",
1451 __func__, rdata->result);
1452 return cifs_readv_discard(server, mid);
1453 }
1454
1455 /* Is there enough to get to the rest of the READ_RSP header? */
1456 if (server->total_read < server->vals->read_rsp_size) {
1457 cifs_dbg(FYI, "%s: server returned short header. got=%u expected=%zu\n",
1458 __func__, server->total_read,
1459 server->vals->read_rsp_size);
1460 rdata->result = -EIO;
1461 return cifs_readv_discard(server, mid);
1462 }
1463
1464 data_offset = server->ops->read_data_offset(buf) + 4;
1465 if (data_offset < server->total_read) {
1466 /*
1467 * win2k8 sometimes sends an offset of 0 when the read
1468 * is beyond the EOF. Treat it as if the data starts just after
1469 * the header.
1470 */
1471 cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n",
1472 __func__, data_offset);
1473 data_offset = server->total_read;
1474 } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1475 /* data_offset is beyond the end of smallbuf */
1476 cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n",
1477 __func__, data_offset);
1478 rdata->result = -EIO;
1479 return cifs_readv_discard(server, mid);
1480 }
1481
1482 cifs_dbg(FYI, "%s: total_read=%u data_offset=%u\n",
1483 __func__, server->total_read, data_offset);
1484
1485 len = data_offset - server->total_read;
1486 if (len > 0) {
1487 /* read any junk before data into the rest of smallbuf */
1488 rdata->iov.iov_base = buf + server->total_read;
1489 rdata->iov.iov_len = len;
1490 length = cifs_readv_from_socket(server, &rdata->iov, 1, len);
1491 if (length < 0)
1492 return length;
1493 server->total_read += length;
1494 }
1495
1496 /* set up first iov for signature check */
1497 rdata->iov.iov_base = buf;
1498 rdata->iov.iov_len = server->total_read;
1499 cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n",
1500 rdata->iov.iov_base, rdata->iov.iov_len);
1501
1502 /* how much data is in the response? */
1503 data_len = server->ops->read_data_length(buf);
1504 if (data_offset + data_len > buflen) {
1505 /* data_len is corrupt -- discard frame */
1506 rdata->result = -EIO;
1507 return cifs_readv_discard(server, mid);
1508 }
1509
1510 length = rdata->read_into_pages(server, rdata, data_len);
1511 if (length < 0)
1512 return length;
1513
1514 server->total_read += length;
1515
1516 cifs_dbg(FYI, "total_read=%u buflen=%u remaining=%u\n",
1517 server->total_read, buflen, data_len);
1518
1519 /* discard anything left over */
1520 if (server->total_read < buflen)
1521 return cifs_readv_discard(server, mid);
1522
1523 dequeue_mid(mid, false);
1524 return length;
1525 }
1526
1527 static void
1528 cifs_readv_callback(struct mid_q_entry *mid)
1529 {
1530 struct cifs_readdata *rdata = mid->callback_data;
1531 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1532 struct TCP_Server_Info *server = tcon->ses->server;
1533 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
1534 .rq_nvec = 1,
1535 .rq_pages = rdata->pages,
1536 .rq_npages = rdata->nr_pages,
1537 .rq_pagesz = rdata->pagesz,
1538 .rq_tailsz = rdata->tailsz };
1539
1540 cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1541 __func__, mid->mid, mid->mid_state, rdata->result,
1542 rdata->bytes);
1543
1544 switch (mid->mid_state) {
1545 case MID_RESPONSE_RECEIVED:
1546 /* result already set, check signature */
1547 if (server->sign) {
1548 int rc = 0;
1549
1550 rc = cifs_verify_signature(&rqst, server,
1551 mid->sequence_number);
1552 if (rc)
1553 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
1554 rc);
1555 }
1556 /* FIXME: should this be counted toward the initiating task? */
1557 task_io_account_read(rdata->got_bytes);
1558 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1559 break;
1560 case MID_REQUEST_SUBMITTED:
1561 case MID_RETRY_NEEDED:
1562 rdata->result = -EAGAIN;
1563 if (server->sign && rdata->got_bytes)
1564 /* reset bytes number since we can not check a sign */
1565 rdata->got_bytes = 0;
1566 /* FIXME: should this be counted toward the initiating task? */
1567 task_io_account_read(rdata->got_bytes);
1568 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1569 break;
1570 default:
1571 rdata->result = -EIO;
1572 }
1573
1574 queue_work(cifsiod_wq, &rdata->work);
1575 DeleteMidQEntry(mid);
1576 add_credits(server, 1, 0);
1577 }
1578
1579 /* cifs_async_readv - send an async write, and set up mid to handle result */
1580 int
1581 cifs_async_readv(struct cifs_readdata *rdata)
1582 {
1583 int rc;
1584 READ_REQ *smb = NULL;
1585 int wct;
1586 struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1587 struct smb_rqst rqst = { .rq_iov = &rdata->iov,
1588 .rq_nvec = 1 };
1589
1590 cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
1591 __func__, rdata->offset, rdata->bytes);
1592
1593 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1594 wct = 12;
1595 else {
1596 wct = 10; /* old style read */
1597 if ((rdata->offset >> 32) > 0) {
1598 /* can not handle this big offset for old */
1599 return -EIO;
1600 }
1601 }
1602
1603 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1604 if (rc)
1605 return rc;
1606
1607 smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1608 smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1609
1610 smb->AndXCommand = 0xFF; /* none */
1611 smb->Fid = rdata->cfile->fid.netfid;
1612 smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1613 if (wct == 12)
1614 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1615 smb->Remaining = 0;
1616 smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1617 smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1618 if (wct == 12)
1619 smb->ByteCount = 0;
1620 else {
1621 /* old style read */
1622 struct smb_com_readx_req *smbr =
1623 (struct smb_com_readx_req *)smb;
1624 smbr->ByteCount = 0;
1625 }
1626
1627 /* 4 for RFC1001 length + 1 for BCC */
1628 rdata->iov.iov_base = smb;
1629 rdata->iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4;
1630
1631 kref_get(&rdata->refcount);
1632 rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
1633 cifs_readv_callback, rdata, 0);
1634
1635 if (rc == 0)
1636 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1637 else
1638 kref_put(&rdata->refcount, cifs_readdata_release);
1639
1640 cifs_small_buf_release(smb);
1641 return rc;
1642 }
1643
1644 int
1645 CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
1646 unsigned int *nbytes, char **buf, int *pbuf_type)
1647 {
1648 int rc = -EACCES;
1649 READ_REQ *pSMB = NULL;
1650 READ_RSP *pSMBr = NULL;
1651 char *pReadData = NULL;
1652 int wct;
1653 int resp_buf_type = 0;
1654 struct kvec iov[1];
1655 __u32 pid = io_parms->pid;
1656 __u16 netfid = io_parms->netfid;
1657 __u64 offset = io_parms->offset;
1658 struct cifs_tcon *tcon = io_parms->tcon;
1659 unsigned int count = io_parms->length;
1660
1661 cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid);
1662 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1663 wct = 12;
1664 else {
1665 wct = 10; /* old style read */
1666 if ((offset >> 32) > 0) {
1667 /* can not handle this big offset for old */
1668 return -EIO;
1669 }
1670 }
1671
1672 *nbytes = 0;
1673 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1674 if (rc)
1675 return rc;
1676
1677 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1678 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1679
1680 /* tcon and ses pointer are checked in smb_init */
1681 if (tcon->ses->server == NULL)
1682 return -ECONNABORTED;
1683
1684 pSMB->AndXCommand = 0xFF; /* none */
1685 pSMB->Fid = netfid;
1686 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1687 if (wct == 12)
1688 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1689
1690 pSMB->Remaining = 0;
1691 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1692 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1693 if (wct == 12)
1694 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1695 else {
1696 /* old style read */
1697 struct smb_com_readx_req *pSMBW =
1698 (struct smb_com_readx_req *)pSMB;
1699 pSMBW->ByteCount = 0;
1700 }
1701
1702 iov[0].iov_base = (char *)pSMB;
1703 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1704 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1705 &resp_buf_type, CIFS_LOG_ERROR);
1706 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1707 pSMBr = (READ_RSP *)iov[0].iov_base;
1708 if (rc) {
1709 cifs_dbg(VFS, "Send error in read = %d\n", rc);
1710 } else {
1711 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1712 data_length = data_length << 16;
1713 data_length += le16_to_cpu(pSMBr->DataLength);
1714 *nbytes = data_length;
1715
1716 /*check that DataLength would not go beyond end of SMB */
1717 if ((data_length > CIFSMaxBufSize)
1718 || (data_length > count)) {
1719 cifs_dbg(FYI, "bad length %d for count %d\n",
1720 data_length, count);
1721 rc = -EIO;
1722 *nbytes = 0;
1723 } else {
1724 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1725 le16_to_cpu(pSMBr->DataOffset);
1726 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1727 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
1728 rc = -EFAULT;
1729 }*/ /* can not use copy_to_user when using page cache*/
1730 if (*buf)
1731 memcpy(*buf, pReadData, data_length);
1732 }
1733 }
1734
1735 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1736 if (*buf) {
1737 free_rsp_buf(resp_buf_type, iov[0].iov_base);
1738 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1739 /* return buffer to caller to free */
1740 *buf = iov[0].iov_base;
1741 if (resp_buf_type == CIFS_SMALL_BUFFER)
1742 *pbuf_type = CIFS_SMALL_BUFFER;
1743 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1744 *pbuf_type = CIFS_LARGE_BUFFER;
1745 } /* else no valid buffer on return - leave as null */
1746
1747 /* Note: On -EAGAIN error only caller can retry on handle based calls
1748 since file handle passed in no longer valid */
1749 return rc;
1750 }
1751
1752
1753 int
1754 CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
1755 unsigned int *nbytes, const char *buf,
1756 const char __user *ubuf, const int long_op)
1757 {
1758 int rc = -EACCES;
1759 WRITE_REQ *pSMB = NULL;
1760 WRITE_RSP *pSMBr = NULL;
1761 int bytes_returned, wct;
1762 __u32 bytes_sent;
1763 __u16 byte_count;
1764 __u32 pid = io_parms->pid;
1765 __u16 netfid = io_parms->netfid;
1766 __u64 offset = io_parms->offset;
1767 struct cifs_tcon *tcon = io_parms->tcon;
1768 unsigned int count = io_parms->length;
1769
1770 *nbytes = 0;
1771
1772 /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
1773 if (tcon->ses == NULL)
1774 return -ECONNABORTED;
1775
1776 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1777 wct = 14;
1778 else {
1779 wct = 12;
1780 if ((offset >> 32) > 0) {
1781 /* can not handle big offset for old srv */
1782 return -EIO;
1783 }
1784 }
1785
1786 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1787 (void **) &pSMBr);
1788 if (rc)
1789 return rc;
1790
1791 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1792 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1793
1794 /* tcon and ses pointer are checked in smb_init */
1795 if (tcon->ses->server == NULL)
1796 return -ECONNABORTED;
1797
1798 pSMB->AndXCommand = 0xFF; /* none */
1799 pSMB->Fid = netfid;
1800 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1801 if (wct == 14)
1802 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1803
1804 pSMB->Reserved = 0xFFFFFFFF;
1805 pSMB->WriteMode = 0;
1806 pSMB->Remaining = 0;
1807
1808 /* Can increase buffer size if buffer is big enough in some cases ie we
1809 can send more if LARGE_WRITE_X capability returned by the server and if
1810 our buffer is big enough or if we convert to iovecs on socket writes
1811 and eliminate the copy to the CIFS buffer */
1812 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1813 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1814 } else {
1815 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1816 & ~0xFF;
1817 }
1818
1819 if (bytes_sent > count)
1820 bytes_sent = count;
1821 pSMB->DataOffset =
1822 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1823 if (buf)
1824 memcpy(pSMB->Data, buf, bytes_sent);
1825 else if (ubuf) {
1826 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1827 cifs_buf_release(pSMB);
1828 return -EFAULT;
1829 }
1830 } else if (count != 0) {
1831 /* No buffer */
1832 cifs_buf_release(pSMB);
1833 return -EINVAL;
1834 } /* else setting file size with write of zero bytes */
1835 if (wct == 14)
1836 byte_count = bytes_sent + 1; /* pad */
1837 else /* wct == 12 */
1838 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1839
1840 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1841 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1842 inc_rfc1001_len(pSMB, byte_count);
1843
1844 if (wct == 14)
1845 pSMB->ByteCount = cpu_to_le16(byte_count);
1846 else { /* old style write has byte count 4 bytes earlier
1847 so 4 bytes pad */
1848 struct smb_com_writex_req *pSMBW =
1849 (struct smb_com_writex_req *)pSMB;
1850 pSMBW->ByteCount = cpu_to_le16(byte_count);
1851 }
1852
1853 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1854 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1855 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1856 if (rc) {
1857 cifs_dbg(FYI, "Send error in write = %d\n", rc);
1858 } else {
1859 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1860 *nbytes = (*nbytes) << 16;
1861 *nbytes += le16_to_cpu(pSMBr->Count);
1862
1863 /*
1864 * Mask off high 16 bits when bytes written as returned by the
1865 * server is greater than bytes requested by the client. Some
1866 * OS/2 servers are known to set incorrect CountHigh values.
1867 */
1868 if (*nbytes > count)
1869 *nbytes &= 0xFFFF;
1870 }
1871
1872 cifs_buf_release(pSMB);
1873
1874 /* Note: On -EAGAIN error only caller can retry on handle based calls
1875 since file handle passed in no longer valid */
1876
1877 return rc;
1878 }
1879
1880 void
1881 cifs_writedata_release(struct kref *refcount)
1882 {
1883 struct cifs_writedata *wdata = container_of(refcount,
1884 struct cifs_writedata, refcount);
1885
1886 if (wdata->cfile)
1887 cifsFileInfo_put(wdata->cfile);
1888
1889 kfree(wdata);
1890 }
1891
1892 /*
1893 * Write failed with a retryable error. Resend the write request. It's also
1894 * possible that the page was redirtied so re-clean the page.
1895 */
1896 static void
1897 cifs_writev_requeue(struct cifs_writedata *wdata)
1898 {
1899 int i, rc = 0;
1900 struct inode *inode = d_inode(wdata->cfile->dentry);
1901 struct TCP_Server_Info *server;
1902 unsigned int rest_len;
1903
1904 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1905 i = 0;
1906 rest_len = wdata->bytes;
1907 do {
1908 struct cifs_writedata *wdata2;
1909 unsigned int j, nr_pages, wsize, tailsz, cur_len;
1910
1911 wsize = server->ops->wp_retry_size(inode);
1912 if (wsize < rest_len) {
1913 nr_pages = wsize / PAGE_CACHE_SIZE;
1914 if (!nr_pages) {
1915 rc = -ENOTSUPP;
1916 break;
1917 }
1918 cur_len = nr_pages * PAGE_CACHE_SIZE;
1919 tailsz = PAGE_CACHE_SIZE;
1920 } else {
1921 nr_pages = DIV_ROUND_UP(rest_len, PAGE_CACHE_SIZE);
1922 cur_len = rest_len;
1923 tailsz = rest_len - (nr_pages - 1) * PAGE_CACHE_SIZE;
1924 }
1925
1926 wdata2 = cifs_writedata_alloc(nr_pages, cifs_writev_complete);
1927 if (!wdata2) {
1928 rc = -ENOMEM;
1929 break;
1930 }
1931
1932 for (j = 0; j < nr_pages; j++) {
1933 wdata2->pages[j] = wdata->pages[i + j];
1934 lock_page(wdata2->pages[j]);
1935 clear_page_dirty_for_io(wdata2->pages[j]);
1936 }
1937
1938 wdata2->sync_mode = wdata->sync_mode;
1939 wdata2->nr_pages = nr_pages;
1940 wdata2->offset = page_offset(wdata2->pages[0]);
1941 wdata2->pagesz = PAGE_CACHE_SIZE;
1942 wdata2->tailsz = tailsz;
1943 wdata2->bytes = cur_len;
1944
1945 wdata2->cfile = find_writable_file(CIFS_I(inode), false);
1946 if (!wdata2->cfile) {
1947 cifs_dbg(VFS, "No writable handles for inode\n");
1948 rc = -EBADF;
1949 break;
1950 }
1951 wdata2->pid = wdata2->cfile->pid;
1952 rc = server->ops->async_writev(wdata2, cifs_writedata_release);
1953
1954 for (j = 0; j < nr_pages; j++) {
1955 unlock_page(wdata2->pages[j]);
1956 if (rc != 0 && rc != -EAGAIN) {
1957 SetPageError(wdata2->pages[j]);
1958 end_page_writeback(wdata2->pages[j]);
1959 page_cache_release(wdata2->pages[j]);
1960 }
1961 }
1962
1963 if (rc) {
1964 kref_put(&wdata2->refcount, cifs_writedata_release);
1965 if (rc == -EAGAIN)
1966 continue;
1967 break;
1968 }
1969
1970 rest_len -= cur_len;
1971 i += nr_pages;
1972 } while (i < wdata->nr_pages);
1973
1974 mapping_set_error(inode->i_mapping, rc);
1975 kref_put(&wdata->refcount, cifs_writedata_release);
1976 }
1977
1978 void
1979 cifs_writev_complete(struct work_struct *work)
1980 {
1981 struct cifs_writedata *wdata = container_of(work,
1982 struct cifs_writedata, work);
1983 struct inode *inode = d_inode(wdata->cfile->dentry);
1984 int i = 0;
1985
1986 if (wdata->result == 0) {
1987 spin_lock(&inode->i_lock);
1988 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
1989 spin_unlock(&inode->i_lock);
1990 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
1991 wdata->bytes);
1992 } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
1993 return cifs_writev_requeue(wdata);
1994
1995 for (i = 0; i < wdata->nr_pages; i++) {
1996 struct page *page = wdata->pages[i];
1997 if (wdata->result == -EAGAIN)
1998 __set_page_dirty_nobuffers(page);
1999 else if (wdata->result < 0)
2000 SetPageError(page);
2001 end_page_writeback(page);
2002 page_cache_release(page);
2003 }
2004 if (wdata->result != -EAGAIN)
2005 mapping_set_error(inode->i_mapping, wdata->result);
2006 kref_put(&wdata->refcount, cifs_writedata_release);
2007 }
2008
2009 struct cifs_writedata *
2010 cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
2011 {
2012 struct cifs_writedata *wdata;
2013
2014 /* writedata + number of page pointers */
2015 wdata = kzalloc(sizeof(*wdata) +
2016 sizeof(struct page *) * nr_pages, GFP_NOFS);
2017 if (wdata != NULL) {
2018 kref_init(&wdata->refcount);
2019 INIT_LIST_HEAD(&wdata->list);
2020 init_completion(&wdata->done);
2021 INIT_WORK(&wdata->work, complete);
2022 }
2023 return wdata;
2024 }
2025
2026 /*
2027 * Check the mid_state and signature on received buffer (if any), and queue the
2028 * workqueue completion task.
2029 */
2030 static void
2031 cifs_writev_callback(struct mid_q_entry *mid)
2032 {
2033 struct cifs_writedata *wdata = mid->callback_data;
2034 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2035 unsigned int written;
2036 WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2037
2038 switch (mid->mid_state) {
2039 case MID_RESPONSE_RECEIVED:
2040 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2041 if (wdata->result != 0)
2042 break;
2043
2044 written = le16_to_cpu(smb->CountHigh);
2045 written <<= 16;
2046 written += le16_to_cpu(smb->Count);
2047 /*
2048 * Mask off high 16 bits when bytes written as returned
2049 * by the server is greater than bytes requested by the
2050 * client. OS/2 servers are known to set incorrect
2051 * CountHigh values.
2052 */
2053 if (written > wdata->bytes)
2054 written &= 0xFFFF;
2055
2056 if (written < wdata->bytes)
2057 wdata->result = -ENOSPC;
2058 else
2059 wdata->bytes = written;
2060 break;
2061 case MID_REQUEST_SUBMITTED:
2062 case MID_RETRY_NEEDED:
2063 wdata->result = -EAGAIN;
2064 break;
2065 default:
2066 wdata->result = -EIO;
2067 break;
2068 }
2069
2070 queue_work(cifsiod_wq, &wdata->work);
2071 DeleteMidQEntry(mid);
2072 add_credits(tcon->ses->server, 1, 0);
2073 }
2074
2075 /* cifs_async_writev - send an async write, and set up mid to handle result */
2076 int
2077 cifs_async_writev(struct cifs_writedata *wdata,
2078 void (*release)(struct kref *kref))
2079 {
2080 int rc = -EACCES;
2081 WRITE_REQ *smb = NULL;
2082 int wct;
2083 struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2084 struct kvec iov;
2085 struct smb_rqst rqst = { };
2086
2087 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2088 wct = 14;
2089 } else {
2090 wct = 12;
2091 if (wdata->offset >> 32 > 0) {
2092 /* can not handle big offset for old srv */
2093 return -EIO;
2094 }
2095 }
2096
2097 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2098 if (rc)
2099 goto async_writev_out;
2100
2101 smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2102 smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
2103
2104 smb->AndXCommand = 0xFF; /* none */
2105 smb->Fid = wdata->cfile->fid.netfid;
2106 smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2107 if (wct == 14)
2108 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2109 smb->Reserved = 0xFFFFFFFF;
2110 smb->WriteMode = 0;
2111 smb->Remaining = 0;
2112
2113 smb->DataOffset =
2114 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2115
2116 /* 4 for RFC1001 length + 1 for BCC */
2117 iov.iov_len = be32_to_cpu(smb->hdr.smb_buf_length) + 4 + 1;
2118 iov.iov_base = smb;
2119
2120 rqst.rq_iov = &iov;
2121 rqst.rq_nvec = 1;
2122 rqst.rq_pages = wdata->pages;
2123 rqst.rq_npages = wdata->nr_pages;
2124 rqst.rq_pagesz = wdata->pagesz;
2125 rqst.rq_tailsz = wdata->tailsz;
2126
2127 cifs_dbg(FYI, "async write at %llu %u bytes\n",
2128 wdata->offset, wdata->bytes);
2129
2130 smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2131 smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2132
2133 if (wct == 14) {
2134 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2135 put_bcc(wdata->bytes + 1, &smb->hdr);
2136 } else {
2137 /* wct == 12 */
2138 struct smb_com_writex_req *smbw =
2139 (struct smb_com_writex_req *)smb;
2140 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2141 put_bcc(wdata->bytes + 5, &smbw->hdr);
2142 iov.iov_len += 4; /* pad bigger by four bytes */
2143 }
2144
2145 kref_get(&wdata->refcount);
2146 rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
2147 cifs_writev_callback, wdata, 0);
2148
2149 if (rc == 0)
2150 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2151 else
2152 kref_put(&wdata->refcount, release);
2153
2154 async_writev_out:
2155 cifs_small_buf_release(smb);
2156 return rc;
2157 }
2158
2159 int
2160 CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
2161 unsigned int *nbytes, struct kvec *iov, int n_vec)
2162 {
2163 int rc = -EACCES;
2164 WRITE_REQ *pSMB = NULL;
2165 int wct;
2166 int smb_hdr_len;
2167 int resp_buf_type = 0;
2168 __u32 pid = io_parms->pid;
2169 __u16 netfid = io_parms->netfid;
2170 __u64 offset = io_parms->offset;
2171 struct cifs_tcon *tcon = io_parms->tcon;
2172 unsigned int count = io_parms->length;
2173
2174 *nbytes = 0;
2175
2176 cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count);
2177
2178 if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2179 wct = 14;
2180 } else {
2181 wct = 12;
2182 if ((offset >> 32) > 0) {
2183 /* can not handle big offset for old srv */
2184 return -EIO;
2185 }
2186 }
2187 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
2188 if (rc)
2189 return rc;
2190
2191 pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2192 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2193
2194 /* tcon and ses pointer are checked in smb_init */
2195 if (tcon->ses->server == NULL)
2196 return -ECONNABORTED;
2197
2198 pSMB->AndXCommand = 0xFF; /* none */
2199 pSMB->Fid = netfid;
2200 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
2201 if (wct == 14)
2202 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
2203 pSMB->Reserved = 0xFFFFFFFF;
2204 pSMB->WriteMode = 0;
2205 pSMB->Remaining = 0;
2206
2207 pSMB->DataOffset =
2208 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2209
2210 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2211 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
2212 /* header + 1 byte pad */
2213 smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
2214 if (wct == 14)
2215 inc_rfc1001_len(pSMB, count + 1);
2216 else /* wct == 12 */
2217 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
2218 if (wct == 14)
2219 pSMB->ByteCount = cpu_to_le16(count + 1);
2220 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2221 struct smb_com_writex_req *pSMBW =
2222 (struct smb_com_writex_req *)pSMB;
2223 pSMBW->ByteCount = cpu_to_le16(count + 5);
2224 }
2225 iov[0].iov_base = pSMB;
2226 if (wct == 14)
2227 iov[0].iov_len = smb_hdr_len + 4;
2228 else /* wct == 12 pad bigger by four bytes */
2229 iov[0].iov_len = smb_hdr_len + 8;
2230
2231
2232 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0);
2233 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2234 if (rc) {
2235 cifs_dbg(FYI, "Send error Write2 = %d\n", rc);
2236 } else if (resp_buf_type == 0) {
2237 /* presumably this can not happen, but best to be safe */
2238 rc = -EIO;
2239 } else {
2240 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
2241 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2242 *nbytes = (*nbytes) << 16;
2243 *nbytes += le16_to_cpu(pSMBr->Count);
2244
2245 /*
2246 * Mask off high 16 bits when bytes written as returned by the
2247 * server is greater than bytes requested by the client. OS/2
2248 * servers are known to set incorrect CountHigh values.
2249 */
2250 if (*nbytes > count)
2251 *nbytes &= 0xFFFF;
2252 }
2253
2254 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2255 free_rsp_buf(resp_buf_type, iov[0].iov_base);
2256
2257 /* Note: On -EAGAIN error only caller can retry on handle based calls
2258 since file handle passed in no longer valid */
2259
2260 return rc;
2261 }
2262
2263 int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
2264 const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
2265 const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2266 {
2267 int rc = 0;
2268 LOCK_REQ *pSMB = NULL;
2269 struct kvec iov[2];
2270 int resp_buf_type;
2271 __u16 count;
2272
2273 cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n",
2274 num_lock, num_unlock);
2275
2276 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2277 if (rc)
2278 return rc;
2279
2280 pSMB->Timeout = 0;
2281 pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2282 pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2283 pSMB->LockType = lock_type;
2284 pSMB->AndXCommand = 0xFF; /* none */
2285 pSMB->Fid = netfid; /* netfid stays le */
2286
2287 count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2288 inc_rfc1001_len(pSMB, count);
2289 pSMB->ByteCount = cpu_to_le16(count);
2290
2291 iov[0].iov_base = (char *)pSMB;
2292 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2293 (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2294 iov[1].iov_base = (char *)buf;
2295 iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2296
2297 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2298 rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP);
2299 if (rc)
2300 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc);
2301
2302 return rc;
2303 }
2304
2305 int
2306 CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
2307 const __u16 smb_file_id, const __u32 netpid, const __u64 len,
2308 const __u64 offset, const __u32 numUnlock,
2309 const __u32 numLock, const __u8 lockType,
2310 const bool waitFlag, const __u8 oplock_level)
2311 {
2312 int rc = 0;
2313 LOCK_REQ *pSMB = NULL;
2314 /* LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2315 int bytes_returned;
2316 int flags = 0;
2317 __u16 count;
2318
2319 cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n",
2320 (int)waitFlag, numLock);
2321 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2322
2323 if (rc)
2324 return rc;
2325
2326 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
2327 /* no response expected */
2328 flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP;
2329 pSMB->Timeout = 0;
2330 } else if (waitFlag) {
2331 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2332 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2333 } else {
2334 pSMB->Timeout = 0;
2335 }
2336
2337 pSMB->NumberOfLocks = cpu_to_le16(numLock);
2338 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2339 pSMB->LockType = lockType;
2340 pSMB->OplockLevel = oplock_level;
2341 pSMB->AndXCommand = 0xFF; /* none */
2342 pSMB->Fid = smb_file_id; /* netfid stays le */
2343
2344 if ((numLock != 0) || (numUnlock != 0)) {
2345 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
2346 /* BB where to store pid high? */
2347 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2348 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2349 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2350 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2351 count = sizeof(LOCKING_ANDX_RANGE);
2352 } else {
2353 /* oplock break */
2354 count = 0;
2355 }
2356 inc_rfc1001_len(pSMB, count);
2357 pSMB->ByteCount = cpu_to_le16(count);
2358
2359 if (waitFlag) {
2360 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2361 (struct smb_hdr *) pSMB, &bytes_returned);
2362 cifs_small_buf_release(pSMB);
2363 } else {
2364 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
2365 /* SMB buffer freed by function above */
2366 }
2367 cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2368 if (rc)
2369 cifs_dbg(FYI, "Send error in Lock = %d\n", rc);
2370
2371 /* Note: On -EAGAIN error only caller can retry on handle based calls
2372 since file handle passed in no longer valid */
2373 return rc;
2374 }
2375
2376 int
2377 CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
2378 const __u16 smb_file_id, const __u32 netpid,
2379 const loff_t start_offset, const __u64 len,
2380 struct file_lock *pLockData, const __u16 lock_type,
2381 const bool waitFlag)
2382 {
2383 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2384 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2385 struct cifs_posix_lock *parm_data;
2386 int rc = 0;
2387 int timeout = 0;
2388 int bytes_returned = 0;
2389 int resp_buf_type = 0;
2390 __u16 params, param_offset, offset, byte_count, count;
2391 struct kvec iov[1];
2392
2393 cifs_dbg(FYI, "Posix Lock\n");
2394
2395 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2396
2397 if (rc)
2398 return rc;
2399
2400 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2401
2402 params = 6;
2403 pSMB->MaxSetupCount = 0;
2404 pSMB->Reserved = 0;
2405 pSMB->Flags = 0;
2406 pSMB->Reserved2 = 0;
2407 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2408 offset = param_offset + params;
2409
2410 count = sizeof(struct cifs_posix_lock);
2411 pSMB->MaxParameterCount = cpu_to_le16(2);
2412 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2413 pSMB->SetupCount = 1;
2414 pSMB->Reserved3 = 0;
2415 if (pLockData)
2416 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2417 else
2418 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2419 byte_count = 3 /* pad */ + params + count;
2420 pSMB->DataCount = cpu_to_le16(count);
2421 pSMB->ParameterCount = cpu_to_le16(params);
2422 pSMB->TotalDataCount = pSMB->DataCount;
2423 pSMB->TotalParameterCount = pSMB->ParameterCount;
2424 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2425 parm_data = (struct cifs_posix_lock *)
2426 (((char *) &pSMB->hdr.Protocol) + offset);
2427
2428 parm_data->lock_type = cpu_to_le16(lock_type);
2429 if (waitFlag) {
2430 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2431 parm_data->lock_flags = cpu_to_le16(1);
2432 pSMB->Timeout = cpu_to_le32(-1);
2433 } else
2434 pSMB->Timeout = 0;
2435
2436 parm_data->pid = cpu_to_le32(netpid);
2437 parm_data->start = cpu_to_le64(start_offset);
2438 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
2439
2440 pSMB->DataOffset = cpu_to_le16(offset);
2441 pSMB->Fid = smb_file_id;
2442 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2443 pSMB->Reserved4 = 0;
2444 inc_rfc1001_len(pSMB, byte_count);
2445 pSMB->ByteCount = cpu_to_le16(byte_count);
2446 if (waitFlag) {
2447 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2448 (struct smb_hdr *) pSMBr, &bytes_returned);
2449 } else {
2450 iov[0].iov_base = (char *)pSMB;
2451 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2452 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2453 &resp_buf_type, timeout);
2454 pSMB = NULL; /* request buf already freed by SendReceive2. Do
2455 not try to free it twice below on exit */
2456 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
2457 }
2458
2459 if (rc) {
2460 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc);
2461 } else if (pLockData) {
2462 /* lock structure can be returned on get */
2463 __u16 data_offset;
2464 __u16 data_count;
2465 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2466
2467 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2468 rc = -EIO; /* bad smb */
2469 goto plk_err_exit;
2470 }
2471 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2472 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2473 if (data_count < sizeof(struct cifs_posix_lock)) {
2474 rc = -EIO;
2475 goto plk_err_exit;
2476 }
2477 parm_data = (struct cifs_posix_lock *)
2478 ((char *)&pSMBr->hdr.Protocol + data_offset);
2479 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
2480 pLockData->fl_type = F_UNLCK;
2481 else {
2482 if (parm_data->lock_type ==
2483 cpu_to_le16(CIFS_RDLCK))
2484 pLockData->fl_type = F_RDLCK;
2485 else if (parm_data->lock_type ==
2486 cpu_to_le16(CIFS_WRLCK))
2487 pLockData->fl_type = F_WRLCK;
2488
2489 pLockData->fl_start = le64_to_cpu(parm_data->start);
2490 pLockData->fl_end = pLockData->fl_start +
2491 le64_to_cpu(parm_data->length) - 1;
2492 pLockData->fl_pid = le32_to_cpu(parm_data->pid);
2493 }
2494 }
2495
2496 plk_err_exit:
2497 if (pSMB)
2498 cifs_small_buf_release(pSMB);
2499
2500 free_rsp_buf(resp_buf_type, iov[0].iov_base);
2501
2502 /* Note: On -EAGAIN error only caller can retry on handle based calls
2503 since file handle passed in no longer valid */
2504
2505 return rc;
2506 }
2507
2508
2509 int
2510 CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2511 {
2512 int rc = 0;
2513 CLOSE_REQ *pSMB = NULL;
2514 cifs_dbg(FYI, "In CIFSSMBClose\n");
2515
2516 /* do not retry on dead session on close */
2517 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2518 if (rc == -EAGAIN)
2519 return 0;
2520 if (rc)
2521 return rc;
2522
2523 pSMB->FileID = (__u16) smb_file_id;
2524 pSMB->LastWriteTime = 0xFFFFFFFF;
2525 pSMB->ByteCount = 0;
2526 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2527 cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
2528 if (rc) {
2529 if (rc != -EINTR) {
2530 /* EINTR is expected when user ctl-c to kill app */
2531 cifs_dbg(VFS, "Send error in Close = %d\n", rc);
2532 }
2533 }
2534
2535 /* Since session is dead, file will be closed on server already */
2536 if (rc == -EAGAIN)
2537 rc = 0;
2538
2539 return rc;
2540 }
2541
2542 int
2543 CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2544 {
2545 int rc = 0;
2546 FLUSH_REQ *pSMB = NULL;
2547 cifs_dbg(FYI, "In CIFSSMBFlush\n");
2548
2549 rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2550 if (rc)
2551 return rc;
2552
2553 pSMB->FileID = (__u16) smb_file_id;
2554 pSMB->ByteCount = 0;
2555 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2556 cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
2557 if (rc)
2558 cifs_dbg(VFS, "Send error in Flush = %d\n", rc);
2559
2560 return rc;
2561 }
2562
2563 int
2564 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
2565 const char *from_name, const char *to_name,
2566 struct cifs_sb_info *cifs_sb)
2567 {
2568 int rc = 0;
2569 RENAME_REQ *pSMB = NULL;
2570 RENAME_RSP *pSMBr = NULL;
2571 int bytes_returned;
2572 int name_len, name_len2;
2573 __u16 count;
2574 int remap = cifs_remap(cifs_sb);
2575
2576 cifs_dbg(FYI, "In CIFSSMBRename\n");
2577 renameRetry:
2578 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2579 (void **) &pSMBr);
2580 if (rc)
2581 return rc;
2582
2583 pSMB->BufferFormat = 0x04;
2584 pSMB->SearchAttributes =
2585 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2586 ATTR_DIRECTORY);
2587
2588 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2589 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2590 from_name, PATH_MAX,
2591 cifs_sb->local_nls, remap);
2592 name_len++; /* trailing null */
2593 name_len *= 2;
2594 pSMB->OldFileName[name_len] = 0x04; /* pad */
2595 /* protocol requires ASCII signature byte on Unicode string */
2596 pSMB->OldFileName[name_len + 1] = 0x00;
2597 name_len2 =
2598 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2599 to_name, PATH_MAX, cifs_sb->local_nls,
2600 remap);
2601 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2602 name_len2 *= 2; /* convert to bytes */
2603 } else { /* BB improve the check for buffer overruns BB */
2604 name_len = strnlen(from_name, PATH_MAX);
2605 name_len++; /* trailing null */
2606 strncpy(pSMB->OldFileName, from_name, name_len);
2607 name_len2 = strnlen(to_name, PATH_MAX);
2608 name_len2++; /* trailing null */
2609 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2610 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
2611 name_len2++; /* trailing null */
2612 name_len2++; /* signature byte */
2613 }
2614
2615 count = 1 /* 1st signature byte */ + name_len + name_len2;
2616 inc_rfc1001_len(pSMB, count);
2617 pSMB->ByteCount = cpu_to_le16(count);
2618
2619 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2620 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2621 cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
2622 if (rc)
2623 cifs_dbg(FYI, "Send error in rename = %d\n", rc);
2624
2625 cifs_buf_release(pSMB);
2626
2627 if (rc == -EAGAIN)
2628 goto renameRetry;
2629
2630 return rc;
2631 }
2632
2633 int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
2634 int netfid, const char *target_name,
2635 const struct nls_table *nls_codepage, int remap)
2636 {
2637 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2638 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2639 struct set_file_rename *rename_info;
2640 char *data_offset;
2641 char dummy_string[30];
2642 int rc = 0;
2643 int bytes_returned = 0;
2644 int len_of_str;
2645 __u16 params, param_offset, offset, count, byte_count;
2646
2647 cifs_dbg(FYI, "Rename to File by handle\n");
2648 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2649 (void **) &pSMBr);
2650 if (rc)
2651 return rc;
2652
2653 params = 6;
2654 pSMB->MaxSetupCount = 0;
2655 pSMB->Reserved = 0;
2656 pSMB->Flags = 0;
2657 pSMB->Timeout = 0;
2658 pSMB->Reserved2 = 0;
2659 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2660 offset = param_offset + params;
2661
2662 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2663 rename_info = (struct set_file_rename *) data_offset;
2664 pSMB->MaxParameterCount = cpu_to_le16(2);
2665 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2666 pSMB->SetupCount = 1;
2667 pSMB->Reserved3 = 0;
2668 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2669 byte_count = 3 /* pad */ + params;
2670 pSMB->ParameterCount = cpu_to_le16(params);
2671 pSMB->TotalParameterCount = pSMB->ParameterCount;
2672 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2673 pSMB->DataOffset = cpu_to_le16(offset);
2674 /* construct random name ".cifs_tmp<inodenum><mid>" */
2675 rename_info->overwrite = cpu_to_le32(1);
2676 rename_info->root_fid = 0;
2677 /* unicode only call */
2678 if (target_name == NULL) {
2679 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2680 len_of_str =
2681 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2682 dummy_string, 24, nls_codepage, remap);
2683 } else {
2684 len_of_str =
2685 cifsConvertToUTF16((__le16 *)rename_info->target_name,
2686 target_name, PATH_MAX, nls_codepage,
2687 remap);
2688 }
2689 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2690 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
2691 byte_count += count;
2692 pSMB->DataCount = cpu_to_le16(count);
2693 pSMB->TotalDataCount = pSMB->DataCount;
2694 pSMB->Fid = netfid;
2695 pSMB->InformationLevel =
2696 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2697 pSMB->Reserved4 = 0;
2698 inc_rfc1001_len(pSMB, byte_count);
2699 pSMB->ByteCount = cpu_to_le16(byte_count);
2700 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2701 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2702 cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
2703 if (rc)
2704 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n",
2705 rc);
2706
2707 cifs_buf_release(pSMB);
2708
2709 /* Note: On -EAGAIN error only caller can retry on handle based calls
2710 since file handle passed in no longer valid */
2711
2712 return rc;
2713 }
2714
2715 int
2716 CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
2717 const char *fromName, const __u16 target_tid, const char *toName,
2718 const int flags, const struct nls_table *nls_codepage, int remap)
2719 {
2720 int rc = 0;
2721 COPY_REQ *pSMB = NULL;
2722 COPY_RSP *pSMBr = NULL;
2723 int bytes_returned;
2724 int name_len, name_len2;
2725 __u16 count;
2726
2727 cifs_dbg(FYI, "In CIFSSMBCopy\n");
2728 copyRetry:
2729 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2730 (void **) &pSMBr);
2731 if (rc)
2732 return rc;
2733
2734 pSMB->BufferFormat = 0x04;
2735 pSMB->Tid2 = target_tid;
2736
2737 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2738
2739 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2740 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2741 fromName, PATH_MAX, nls_codepage,
2742 remap);
2743 name_len++; /* trailing null */
2744 name_len *= 2;
2745 pSMB->OldFileName[name_len] = 0x04; /* pad */
2746 /* protocol requires ASCII signature byte on Unicode string */
2747 pSMB->OldFileName[name_len + 1] = 0x00;
2748 name_len2 =
2749 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2750 toName, PATH_MAX, nls_codepage, remap);
2751 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2752 name_len2 *= 2; /* convert to bytes */
2753 } else { /* BB improve the check for buffer overruns BB */
2754 name_len = strnlen(fromName, PATH_MAX);
2755 name_len++; /* trailing null */
2756 strncpy(pSMB->OldFileName, fromName, name_len);
2757 name_len2 = strnlen(toName, PATH_MAX);
2758 name_len2++; /* trailing null */
2759 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2760 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2761 name_len2++; /* trailing null */
2762 name_len2++; /* signature byte */
2763 }
2764
2765 count = 1 /* 1st signature byte */ + name_len + name_len2;
2766 inc_rfc1001_len(pSMB, count);
2767 pSMB->ByteCount = cpu_to_le16(count);
2768
2769 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2770 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2771 if (rc) {
2772 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n",
2773 rc, le16_to_cpu(pSMBr->CopyCount));
2774 }
2775 cifs_buf_release(pSMB);
2776
2777 if (rc == -EAGAIN)
2778 goto copyRetry;
2779
2780 return rc;
2781 }
2782
2783 int
2784 CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
2785 const char *fromName, const char *toName,
2786 const struct nls_table *nls_codepage, int remap)
2787 {
2788 TRANSACTION2_SPI_REQ *pSMB = NULL;
2789 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2790 char *data_offset;
2791 int name_len;
2792 int name_len_target;
2793 int rc = 0;
2794 int bytes_returned = 0;
2795 __u16 params, param_offset, offset, byte_count;
2796
2797 cifs_dbg(FYI, "In Symlink Unix style\n");
2798 createSymLinkRetry:
2799 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2800 (void **) &pSMBr);
2801 if (rc)
2802 return rc;
2803
2804 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2805 name_len =
2806 cifsConvertToUTF16((__le16 *) pSMB->FileName, fromName,
2807 /* find define for this maxpathcomponent */
2808 PATH_MAX, nls_codepage, remap);
2809 name_len++; /* trailing null */
2810 name_len *= 2;
2811
2812 } else { /* BB improve the check for buffer overruns BB */
2813 name_len = strnlen(fromName, PATH_MAX);
2814 name_len++; /* trailing null */
2815 strncpy(pSMB->FileName, fromName, name_len);
2816 }
2817 params = 6 + name_len;
2818 pSMB->MaxSetupCount = 0;
2819 pSMB->Reserved = 0;
2820 pSMB->Flags = 0;
2821 pSMB->Timeout = 0;
2822 pSMB->Reserved2 = 0;
2823 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2824 InformationLevel) - 4;
2825 offset = param_offset + params;
2826
2827 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2828 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2829 name_len_target =
2830 cifsConvertToUTF16((__le16 *) data_offset, toName,
2831 /* find define for this maxpathcomponent */
2832 PATH_MAX, nls_codepage, remap);
2833 name_len_target++; /* trailing null */
2834 name_len_target *= 2;
2835 } else { /* BB improve the check for buffer overruns BB */
2836 name_len_target = strnlen(toName, PATH_MAX);
2837 name_len_target++; /* trailing null */
2838 strncpy(data_offset, toName, name_len_target);
2839 }
2840
2841 pSMB->MaxParameterCount = cpu_to_le16(2);
2842 /* BB find exact max on data count below from sess */
2843 pSMB->MaxDataCount = cpu_to_le16(1000);
2844 pSMB->SetupCount = 1;
2845 pSMB->Reserved3 = 0;
2846 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2847 byte_count = 3 /* pad */ + params + name_len_target;
2848 pSMB->DataCount = cpu_to_le16(name_len_target);
2849 pSMB->ParameterCount = cpu_to_le16(params);
2850 pSMB->TotalDataCount = pSMB->DataCount;
2851 pSMB->TotalParameterCount = pSMB->ParameterCount;
2852 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2853 pSMB->DataOffset = cpu_to_le16(offset);
2854 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2855 pSMB->Reserved4 = 0;
2856 inc_rfc1001_len(pSMB, byte_count);
2857 pSMB->ByteCount = cpu_to_le16(byte_count);
2858 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2859 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2860 cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
2861 if (rc)
2862 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n",
2863 rc);
2864
2865 cifs_buf_release(pSMB);
2866
2867 if (rc == -EAGAIN)
2868 goto createSymLinkRetry;
2869
2870 return rc;
2871 }
2872
2873 int
2874 CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2875 const char *fromName, const char *toName,
2876 const struct nls_table *nls_codepage, int remap)
2877 {
2878 TRANSACTION2_SPI_REQ *pSMB = NULL;
2879 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2880 char *data_offset;
2881 int name_len;
2882 int name_len_target;
2883 int rc = 0;
2884 int bytes_returned = 0;
2885 __u16 params, param_offset, offset, byte_count;
2886
2887 cifs_dbg(FYI, "In Create Hard link Unix style\n");
2888 createHardLinkRetry:
2889 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2890 (void **) &pSMBr);
2891 if (rc)
2892 return rc;
2893
2894 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2895 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
2896 PATH_MAX, nls_codepage, remap);
2897 name_len++; /* trailing null */
2898 name_len *= 2;
2899
2900 } else { /* BB improve the check for buffer overruns BB */
2901 name_len = strnlen(toName, PATH_MAX);
2902 name_len++; /* trailing null */
2903 strncpy(pSMB->FileName, toName, name_len);
2904 }
2905 params = 6 + name_len;
2906 pSMB->MaxSetupCount = 0;
2907 pSMB->Reserved = 0;
2908 pSMB->Flags = 0;
2909 pSMB->Timeout = 0;
2910 pSMB->Reserved2 = 0;
2911 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2912 InformationLevel) - 4;
2913 offset = param_offset + params;
2914
2915 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2916 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2917 name_len_target =
2918 cifsConvertToUTF16((__le16 *) data_offset, fromName,
2919 PATH_MAX, nls_codepage, remap);
2920 name_len_target++; /* trailing null */
2921 name_len_target *= 2;
2922 } else { /* BB improve the check for buffer overruns BB */
2923 name_len_target = strnlen(fromName, PATH_MAX);
2924 name_len_target++; /* trailing null */
2925 strncpy(data_offset, fromName, name_len_target);
2926 }
2927
2928 pSMB->MaxParameterCount = cpu_to_le16(2);
2929 /* BB find exact max on data count below from sess*/
2930 pSMB->MaxDataCount = cpu_to_le16(1000);
2931 pSMB->SetupCount = 1;
2932 pSMB->Reserved3 = 0;
2933 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2934 byte_count = 3 /* pad */ + params + name_len_target;
2935 pSMB->ParameterCount = cpu_to_le16(params);
2936 pSMB->TotalParameterCount = pSMB->ParameterCount;
2937 pSMB->DataCount = cpu_to_le16(name_len_target);
2938 pSMB->TotalDataCount = pSMB->DataCount;
2939 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2940 pSMB->DataOffset = cpu_to_le16(offset);
2941 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2942 pSMB->Reserved4 = 0;
2943 inc_rfc1001_len(pSMB, byte_count);
2944 pSMB->ByteCount = cpu_to_le16(byte_count);
2945 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2946 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2947 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
2948 if (rc)
2949 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n",
2950 rc);
2951
2952 cifs_buf_release(pSMB);
2953 if (rc == -EAGAIN)
2954 goto createHardLinkRetry;
2955
2956 return rc;
2957 }
2958
2959 int
2960 CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2961 const char *from_name, const char *to_name,
2962 struct cifs_sb_info *cifs_sb)
2963 {
2964 int rc = 0;
2965 NT_RENAME_REQ *pSMB = NULL;
2966 RENAME_RSP *pSMBr = NULL;
2967 int bytes_returned;
2968 int name_len, name_len2;
2969 __u16 count;
2970 int remap = cifs_remap(cifs_sb);
2971
2972 cifs_dbg(FYI, "In CIFSCreateHardLink\n");
2973 winCreateHardLinkRetry:
2974
2975 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2976 (void **) &pSMBr);
2977 if (rc)
2978 return rc;
2979
2980 pSMB->SearchAttributes =
2981 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2982 ATTR_DIRECTORY);
2983 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2984 pSMB->ClusterCount = 0;
2985
2986 pSMB->BufferFormat = 0x04;
2987
2988 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2989 name_len =
2990 cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
2991 PATH_MAX, cifs_sb->local_nls, remap);
2992 name_len++; /* trailing null */
2993 name_len *= 2;
2994
2995 /* protocol specifies ASCII buffer format (0x04) for unicode */
2996 pSMB->OldFileName[name_len] = 0x04;
2997 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
2998 name_len2 =
2999 cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3000 to_name, PATH_MAX, cifs_sb->local_nls,
3001 remap);
3002 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
3003 name_len2 *= 2; /* convert to bytes */
3004 } else { /* BB improve the check for buffer overruns BB */
3005 name_len = strnlen(from_name, PATH_MAX);
3006 name_len++; /* trailing null */
3007 strncpy(pSMB->OldFileName, from_name, name_len);
3008 name_len2 = strnlen(to_name, PATH_MAX);
3009 name_len2++; /* trailing null */
3010 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
3011 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
3012 name_len2++; /* trailing null */
3013 name_len2++; /* signature byte */
3014 }
3015
3016 count = 1 /* string type byte */ + name_len + name_len2;
3017 inc_rfc1001_len(pSMB, count);
3018 pSMB->ByteCount = cpu_to_le16(count);
3019
3020 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3021 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3022 cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
3023 if (rc)
3024 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
3025
3026 cifs_buf_release(pSMB);
3027 if (rc == -EAGAIN)
3028 goto winCreateHardLinkRetry;
3029
3030 return rc;
3031 }
3032
3033 int
3034 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3035 const unsigned char *searchName, char **symlinkinfo,
3036 const struct nls_table *nls_codepage, int remap)
3037 {
3038 /* SMB_QUERY_FILE_UNIX_LINK */
3039 TRANSACTION2_QPI_REQ *pSMB = NULL;
3040 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3041 int rc = 0;
3042 int bytes_returned;
3043 int name_len;
3044 __u16 params, byte_count;
3045 char *data_start;
3046
3047 cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
3048
3049 querySymLinkRetry:
3050 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3051 (void **) &pSMBr);
3052 if (rc)
3053 return rc;
3054
3055 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3056 name_len =
3057 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3058 searchName, PATH_MAX, nls_codepage,
3059 remap);
3060 name_len++; /* trailing null */
3061 name_len *= 2;
3062 } else { /* BB improve the check for buffer overruns BB */
3063 name_len = strnlen(searchName, PATH_MAX);
3064 name_len++; /* trailing null */
3065 strncpy(pSMB->FileName, searchName, name_len);
3066 }
3067
3068 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3069 pSMB->TotalDataCount = 0;
3070 pSMB->MaxParameterCount = cpu_to_le16(2);
3071 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3072 pSMB->MaxSetupCount = 0;
3073 pSMB->Reserved = 0;
3074 pSMB->Flags = 0;
3075 pSMB->Timeout = 0;
3076 pSMB->Reserved2 = 0;
3077 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3078 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3079 pSMB->DataCount = 0;
3080 pSMB->DataOffset = 0;
3081 pSMB->SetupCount = 1;
3082 pSMB->Reserved3 = 0;
3083 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3084 byte_count = params + 1 /* pad */ ;
3085 pSMB->TotalParameterCount = cpu_to_le16(params);
3086 pSMB->ParameterCount = pSMB->TotalParameterCount;
3087 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3088 pSMB->Reserved4 = 0;
3089 inc_rfc1001_len(pSMB, byte_count);
3090 pSMB->ByteCount = cpu_to_le16(byte_count);
3091
3092 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3093 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3094 if (rc) {
3095 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
3096 } else {
3097 /* decode response */
3098
3099 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3100 /* BB also check enough total bytes returned */
3101 if (rc || get_bcc(&pSMBr->hdr) < 2)
3102 rc = -EIO;
3103 else {
3104 bool is_unicode;
3105 u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3106
3107 data_start = ((char *) &pSMBr->hdr.Protocol) +
3108 le16_to_cpu(pSMBr->t2.DataOffset);
3109
3110 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3111 is_unicode = true;
3112 else
3113 is_unicode = false;
3114
3115 /* BB FIXME investigate remapping reserved chars here */
3116 *symlinkinfo = cifs_strndup_from_utf16(data_start,
3117 count, is_unicode, nls_codepage);
3118 if (!*symlinkinfo)
3119 rc = -ENOMEM;
3120 }
3121 }
3122 cifs_buf_release(pSMB);
3123 if (rc == -EAGAIN)
3124 goto querySymLinkRetry;
3125 return rc;
3126 }
3127
3128 /*
3129 * Recent Windows versions now create symlinks more frequently
3130 * and they use the "reparse point" mechanism below. We can of course
3131 * do symlinks nicely to Samba and other servers which support the
3132 * CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3133 * "MF" symlinks optionally, but for recent Windows we really need to
3134 * reenable the code below and fix the cifs_symlink callers to handle this.
3135 * In the interim this code has been moved to its own config option so
3136 * it is not compiled in by default until callers fixed up and more tested.
3137 */
3138 int
3139 CIFSSMBQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3140 __u16 fid, char **symlinkinfo,
3141 const struct nls_table *nls_codepage)
3142 {
3143 int rc = 0;
3144 int bytes_returned;
3145 struct smb_com_transaction_ioctl_req *pSMB;
3146 struct smb_com_transaction_ioctl_rsp *pSMBr;
3147 bool is_unicode;
3148 unsigned int sub_len;
3149 char *sub_start;
3150 struct reparse_symlink_data *reparse_buf;
3151 struct reparse_posix_data *posix_buf;
3152 __u32 data_offset, data_count;
3153 char *end_of_smb;
3154
3155 cifs_dbg(FYI, "In Windows reparse style QueryLink for fid %u\n", fid);
3156 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3157 (void **) &pSMBr);
3158 if (rc)
3159 return rc;
3160
3161 pSMB->TotalParameterCount = 0 ;
3162 pSMB->TotalDataCount = 0;
3163 pSMB->MaxParameterCount = cpu_to_le32(2);
3164 /* BB find exact data count max from sess structure BB */
3165 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3166 pSMB->MaxSetupCount = 4;
3167 pSMB->Reserved = 0;
3168 pSMB->ParameterOffset = 0;
3169 pSMB->DataCount = 0;
3170 pSMB->DataOffset = 0;
3171 pSMB->SetupCount = 4;
3172 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3173 pSMB->ParameterCount = pSMB->TotalParameterCount;
3174 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3175 pSMB->IsFsctl = 1; /* FSCTL */
3176 pSMB->IsRootFlag = 0;
3177 pSMB->Fid = fid; /* file handle always le */
3178 pSMB->ByteCount = 0;
3179
3180 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3181 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3182 if (rc) {
3183 cifs_dbg(FYI, "Send error in QueryReparseLinkInfo = %d\n", rc);
3184 goto qreparse_out;
3185 }
3186
3187 data_offset = le32_to_cpu(pSMBr->DataOffset);
3188 data_count = le32_to_cpu(pSMBr->DataCount);
3189 if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3190 /* BB also check enough total bytes returned */
3191 rc = -EIO; /* bad smb */
3192 goto qreparse_out;
3193 }
3194 if (!data_count || (data_count > 2048)) {
3195 rc = -EIO;
3196 cifs_dbg(FYI, "Invalid return data count on get reparse info ioctl\n");
3197 goto qreparse_out;
3198 }
3199 end_of_smb = 2 + get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
3200 reparse_buf = (struct reparse_symlink_data *)
3201 ((char *)&pSMBr->hdr.Protocol + data_offset);
3202 if ((char *)reparse_buf >= end_of_smb) {
3203 rc = -EIO;
3204 goto qreparse_out;
3205 }
3206 if (reparse_buf->ReparseTag == cpu_to_le32(IO_REPARSE_TAG_NFS)) {
3207 cifs_dbg(FYI, "NFS style reparse tag\n");
3208 posix_buf = (struct reparse_posix_data *)reparse_buf;
3209
3210 if (posix_buf->InodeType != cpu_to_le64(NFS_SPECFILE_LNK)) {
3211 cifs_dbg(FYI, "unsupported file type 0x%llx\n",
3212 le64_to_cpu(posix_buf->InodeType));
3213 rc = -EOPNOTSUPP;
3214 goto qreparse_out;
3215 }
3216 is_unicode = true;
3217 sub_len = le16_to_cpu(reparse_buf->ReparseDataLength);
3218 if (posix_buf->PathBuffer + sub_len > end_of_smb) {
3219 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3220 rc = -EIO;
3221 goto qreparse_out;
3222 }
3223 *symlinkinfo = cifs_strndup_from_utf16(posix_buf->PathBuffer,
3224 sub_len, is_unicode, nls_codepage);
3225 goto qreparse_out;
3226 } else if (reparse_buf->ReparseTag !=
3227 cpu_to_le32(IO_REPARSE_TAG_SYMLINK)) {
3228 rc = -EOPNOTSUPP;
3229 goto qreparse_out;
3230 }
3231
3232 /* Reparse tag is NTFS symlink */
3233 sub_start = le16_to_cpu(reparse_buf->SubstituteNameOffset) +
3234 reparse_buf->PathBuffer;
3235 sub_len = le16_to_cpu(reparse_buf->SubstituteNameLength);
3236 if (sub_start + sub_len > end_of_smb) {
3237 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3238 rc = -EIO;
3239 goto qreparse_out;
3240 }
3241 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3242 is_unicode = true;
3243 else
3244 is_unicode = false;
3245
3246 /* BB FIXME investigate remapping reserved chars here */
3247 *symlinkinfo = cifs_strndup_from_utf16(sub_start, sub_len, is_unicode,
3248 nls_codepage);
3249 if (!*symlinkinfo)
3250 rc = -ENOMEM;
3251 qreparse_out:
3252 cifs_buf_release(pSMB);
3253
3254 /*
3255 * Note: On -EAGAIN error only caller can retry on handle based calls
3256 * since file handle passed in no longer valid.
3257 */
3258 return rc;
3259 }
3260
3261 int
3262 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
3263 __u16 fid)
3264 {
3265 int rc = 0;
3266 int bytes_returned;
3267 struct smb_com_transaction_compr_ioctl_req *pSMB;
3268 struct smb_com_transaction_ioctl_rsp *pSMBr;
3269
3270 cifs_dbg(FYI, "Set compression for %u\n", fid);
3271 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3272 (void **) &pSMBr);
3273 if (rc)
3274 return rc;
3275
3276 pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT);
3277
3278 pSMB->TotalParameterCount = 0;
3279 pSMB->TotalDataCount = cpu_to_le32(2);
3280 pSMB->MaxParameterCount = 0;
3281 pSMB->MaxDataCount = 0;
3282 pSMB->MaxSetupCount = 4;
3283 pSMB->Reserved = 0;
3284 pSMB->ParameterOffset = 0;
3285 pSMB->DataCount = cpu_to_le32(2);
3286 pSMB->DataOffset =
3287 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req,
3288 compression_state) - 4); /* 84 */
3289 pSMB->SetupCount = 4;
3290 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3291 pSMB->ParameterCount = 0;
3292 pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION);
3293 pSMB->IsFsctl = 1; /* FSCTL */
3294 pSMB->IsRootFlag = 0;
3295 pSMB->Fid = fid; /* file handle always le */
3296 /* 3 byte pad, followed by 2 byte compress state */
3297 pSMB->ByteCount = cpu_to_le16(5);
3298 inc_rfc1001_len(pSMB, 5);
3299
3300 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3301 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3302 if (rc)
3303 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc);
3304
3305 cifs_buf_release(pSMB);
3306
3307 /*
3308 * Note: On -EAGAIN error only caller can retry on handle based calls
3309 * since file handle passed in no longer valid.
3310 */
3311 return rc;
3312 }
3313
3314
3315 #ifdef CONFIG_CIFS_POSIX
3316
3317 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3318 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
3319 struct cifs_posix_ace *cifs_ace)
3320 {
3321 /* u8 cifs fields do not need le conversion */
3322 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3323 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
3324 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
3325 /*
3326 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3327 ace->e_perm, ace->e_tag, ace->e_id);
3328 */
3329
3330 return;
3331 }
3332
3333 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3334 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3335 const int acl_type, const int size_of_data_area)
3336 {
3337 int size = 0;
3338 int i;
3339 __u16 count;
3340 struct cifs_posix_ace *pACE;
3341 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3342 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
3343
3344 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3345 return -EOPNOTSUPP;
3346
3347 if (acl_type & ACL_TYPE_ACCESS) {
3348 count = le16_to_cpu(cifs_acl->access_entry_count);
3349 pACE = &cifs_acl->ace_array[0];
3350 size = sizeof(struct cifs_posix_acl);
3351 size += sizeof(struct cifs_posix_ace) * count;
3352 /* check if we would go beyond end of SMB */
3353 if (size_of_data_area < size) {
3354 cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
3355 size_of_data_area, size);
3356 return -EINVAL;
3357 }
3358 } else if (acl_type & ACL_TYPE_DEFAULT) {
3359 count = le16_to_cpu(cifs_acl->access_entry_count);
3360 size = sizeof(struct cifs_posix_acl);
3361 size += sizeof(struct cifs_posix_ace) * count;
3362 /* skip past access ACEs to get to default ACEs */
3363 pACE = &cifs_acl->ace_array[count];
3364 count = le16_to_cpu(cifs_acl->default_entry_count);
3365 size += sizeof(struct cifs_posix_ace) * count;
3366 /* check if we would go beyond end of SMB */
3367 if (size_of_data_area < size)
3368 return -EINVAL;
3369 } else {
3370 /* illegal type */
3371 return -EINVAL;
3372 }
3373
3374 size = posix_acl_xattr_size(count);
3375 if ((buflen == 0) || (local_acl == NULL)) {
3376 /* used to query ACL EA size */
3377 } else if (size > buflen) {
3378 return -ERANGE;
3379 } else /* buffer big enough */ {
3380 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
3381 for (i = 0; i < count ; i++) {
3382 cifs_convert_ace(&local_acl->a_entries[i], pACE);
3383 pACE++;
3384 }
3385 }
3386 return size;
3387 }
3388
3389 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3390 const posix_acl_xattr_entry *local_ace)
3391 {
3392 __u16 rc = 0; /* 0 = ACL converted ok */
3393
3394 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3395 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
3396 /* BB is there a better way to handle the large uid? */
3397 if (local_ace->e_id == cpu_to_le32(-1)) {
3398 /* Probably no need to le convert -1 on any arch but can not hurt */
3399 cifs_ace->cifs_uid = cpu_to_le64(-1);
3400 } else
3401 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
3402 /*
3403 cifs_dbg(FYI, "perm %d tag %d id %d\n",
3404 ace->e_perm, ace->e_tag, ace->e_id);
3405 */
3406 return rc;
3407 }
3408
3409 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3410 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3411 const int buflen, const int acl_type)
3412 {
3413 __u16 rc = 0;
3414 struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3415 posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
3416 int count;
3417 int i;
3418
3419 if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
3420 return 0;
3421
3422 count = posix_acl_xattr_count((size_t)buflen);
3423 cifs_dbg(FYI, "setting acl with %d entries from buf of length %d and version of %d\n",
3424 count, buflen, le32_to_cpu(local_acl->a_version));
3425 if (le32_to_cpu(local_acl->a_version) != 2) {
3426 cifs_dbg(FYI, "unknown POSIX ACL version %d\n",
3427 le32_to_cpu(local_acl->a_version));
3428 return 0;
3429 }
3430 cifs_acl->version = cpu_to_le16(1);
3431 if (acl_type == ACL_TYPE_ACCESS) {
3432 cifs_acl->access_entry_count = cpu_to_le16(count);
3433 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF);
3434 } else if (acl_type == ACL_TYPE_DEFAULT) {
3435 cifs_acl->default_entry_count = cpu_to_le16(count);
3436 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF);
3437 } else {
3438 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
3439 return 0;
3440 }
3441 for (i = 0; i < count; i++) {
3442 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
3443 &local_acl->a_entries[i]);
3444 if (rc != 0) {
3445 /* ACE not converted */
3446 break;
3447 }
3448 }
3449 if (rc == 0) {
3450 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3451 rc += sizeof(struct cifs_posix_acl);
3452 /* BB add check to make sure ACL does not overflow SMB */
3453 }
3454 return rc;
3455 }
3456
3457 int
3458 CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3459 const unsigned char *searchName,
3460 char *acl_inf, const int buflen, const int acl_type,
3461 const struct nls_table *nls_codepage, int remap)
3462 {
3463 /* SMB_QUERY_POSIX_ACL */
3464 TRANSACTION2_QPI_REQ *pSMB = NULL;
3465 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3466 int rc = 0;
3467 int bytes_returned;
3468 int name_len;
3469 __u16 params, byte_count;
3470
3471 cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
3472
3473 queryAclRetry:
3474 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3475 (void **) &pSMBr);
3476 if (rc)
3477 return rc;
3478
3479 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3480 name_len =
3481 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3482 searchName, PATH_MAX, nls_codepage,
3483 remap);
3484 name_len++; /* trailing null */
3485 name_len *= 2;
3486 pSMB->FileName[name_len] = 0;
3487 pSMB->FileName[name_len+1] = 0;
3488 } else { /* BB improve the check for buffer overruns BB */
3489 name_len = strnlen(searchName, PATH_MAX);
3490 name_len++; /* trailing null */
3491 strncpy(pSMB->FileName, searchName, name_len);
3492 }
3493
3494 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3495 pSMB->TotalDataCount = 0;
3496 pSMB->MaxParameterCount = cpu_to_le16(2);
3497 /* BB find exact max data count below from sess structure BB */
3498 pSMB->MaxDataCount = cpu_to_le16(4000);
3499 pSMB->MaxSetupCount = 0;
3500 pSMB->Reserved = 0;
3501 pSMB->Flags = 0;
3502 pSMB->Timeout = 0;
3503 pSMB->Reserved2 = 0;
3504 pSMB->ParameterOffset = cpu_to_le16(
3505 offsetof(struct smb_com_transaction2_qpi_req,
3506 InformationLevel) - 4);
3507 pSMB->DataCount = 0;
3508 pSMB->DataOffset = 0;
3509 pSMB->SetupCount = 1;
3510 pSMB->Reserved3 = 0;
3511 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3512 byte_count = params + 1 /* pad */ ;
3513 pSMB->TotalParameterCount = cpu_to_le16(params);
3514 pSMB->ParameterCount = pSMB->TotalParameterCount;
3515 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3516 pSMB->Reserved4 = 0;
3517 inc_rfc1001_len(pSMB, byte_count);
3518 pSMB->ByteCount = cpu_to_le16(byte_count);
3519
3520 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3521 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3522 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3523 if (rc) {
3524 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
3525 } else {
3526 /* decode response */
3527
3528 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3529 /* BB also check enough total bytes returned */
3530 if (rc || get_bcc(&pSMBr->hdr) < 2)
3531 rc = -EIO; /* bad smb */
3532 else {
3533 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3534 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3535 rc = cifs_copy_posix_acl(acl_inf,
3536 (char *)&pSMBr->hdr.Protocol+data_offset,
3537 buflen, acl_type, count);
3538 }
3539 }
3540 cifs_buf_release(pSMB);
3541 if (rc == -EAGAIN)
3542 goto queryAclRetry;
3543 return rc;
3544 }
3545
3546 int
3547 CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3548 const unsigned char *fileName,
3549 const char *local_acl, const int buflen,
3550 const int acl_type,
3551 const struct nls_table *nls_codepage, int remap)
3552 {
3553 struct smb_com_transaction2_spi_req *pSMB = NULL;
3554 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3555 char *parm_data;
3556 int name_len;
3557 int rc = 0;
3558 int bytes_returned = 0;
3559 __u16 params, byte_count, data_count, param_offset, offset;
3560
3561 cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
3562 setAclRetry:
3563 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3564 (void **) &pSMBr);
3565 if (rc)
3566 return rc;
3567 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3568 name_len =
3569 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3570 PATH_MAX, nls_codepage, remap);
3571 name_len++; /* trailing null */
3572 name_len *= 2;
3573 } else { /* BB improve the check for buffer overruns BB */
3574 name_len = strnlen(fileName, PATH_MAX);
3575 name_len++; /* trailing null */
3576 strncpy(pSMB->FileName, fileName, name_len);
3577 }
3578 params = 6 + name_len;
3579 pSMB->MaxParameterCount = cpu_to_le16(2);
3580 /* BB find max SMB size from sess */
3581 pSMB->MaxDataCount = cpu_to_le16(1000);
3582 pSMB->MaxSetupCount = 0;
3583 pSMB->Reserved = 0;
3584 pSMB->Flags = 0;
3585 pSMB->Timeout = 0;
3586 pSMB->Reserved2 = 0;
3587 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3588 InformationLevel) - 4;
3589 offset = param_offset + params;
3590 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3591 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3592
3593 /* convert to on the wire format for POSIX ACL */
3594 data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
3595
3596 if (data_count == 0) {
3597 rc = -EOPNOTSUPP;
3598 goto setACLerrorExit;
3599 }
3600 pSMB->DataOffset = cpu_to_le16(offset);
3601 pSMB->SetupCount = 1;
3602 pSMB->Reserved3 = 0;
3603 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3604 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3605 byte_count = 3 /* pad */ + params + data_count;
3606 pSMB->DataCount = cpu_to_le16(data_count);
3607 pSMB->TotalDataCount = pSMB->DataCount;
3608 pSMB->ParameterCount = cpu_to_le16(params);
3609 pSMB->TotalParameterCount = pSMB->ParameterCount;
3610 pSMB->Reserved4 = 0;
3611 inc_rfc1001_len(pSMB, byte_count);
3612 pSMB->ByteCount = cpu_to_le16(byte_count);
3613 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3614 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3615 if (rc)
3616 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
3617
3618 setACLerrorExit:
3619 cifs_buf_release(pSMB);
3620 if (rc == -EAGAIN)
3621 goto setAclRetry;
3622 return rc;
3623 }
3624
3625 /* BB fix tabs in this function FIXME BB */
3626 int
3627 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
3628 const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3629 {
3630 int rc = 0;
3631 struct smb_t2_qfi_req *pSMB = NULL;
3632 struct smb_t2_qfi_rsp *pSMBr = NULL;
3633 int bytes_returned;
3634 __u16 params, byte_count;
3635
3636 cifs_dbg(FYI, "In GetExtAttr\n");
3637 if (tcon == NULL)
3638 return -ENODEV;
3639
3640 GetExtAttrRetry:
3641 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3642 (void **) &pSMBr);
3643 if (rc)
3644 return rc;
3645
3646 params = 2 /* level */ + 2 /* fid */;
3647 pSMB->t2.TotalDataCount = 0;
3648 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3649 /* BB find exact max data count below from sess structure BB */
3650 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3651 pSMB->t2.MaxSetupCount = 0;
3652 pSMB->t2.Reserved = 0;
3653 pSMB->t2.Flags = 0;
3654 pSMB->t2.Timeout = 0;
3655 pSMB->t2.Reserved2 = 0;
3656 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3657 Fid) - 4);
3658 pSMB->t2.DataCount = 0;
3659 pSMB->t2.DataOffset = 0;
3660 pSMB->t2.SetupCount = 1;
3661 pSMB->t2.Reserved3 = 0;
3662 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3663 byte_count = params + 1 /* pad */ ;
3664 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3665 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3666 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3667 pSMB->Pad = 0;
3668 pSMB->Fid = netfid;
3669 inc_rfc1001_len(pSMB, byte_count);
3670 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3671
3672 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3673 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3674 if (rc) {
3675 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
3676 } else {
3677 /* decode response */
3678 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3679 /* BB also check enough total bytes returned */
3680 if (rc || get_bcc(&pSMBr->hdr) < 2)
3681 /* If rc should we check for EOPNOSUPP and
3682 disable the srvino flag? or in caller? */
3683 rc = -EIO; /* bad smb */
3684 else {
3685 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3686 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3687 struct file_chattr_info *pfinfo;
3688 /* BB Do we need a cast or hash here ? */
3689 if (count != 16) {
3690 cifs_dbg(FYI, "Illegal size ret in GetExtAttr\n");
3691 rc = -EIO;
3692 goto GetExtAttrOut;
3693 }
3694 pfinfo = (struct file_chattr_info *)
3695 (data_offset + (char *) &pSMBr->hdr.Protocol);
3696 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3697 *pMask = le64_to_cpu(pfinfo->mask);
3698 }
3699 }
3700 GetExtAttrOut:
3701 cifs_buf_release(pSMB);
3702 if (rc == -EAGAIN)
3703 goto GetExtAttrRetry;
3704 return rc;
3705 }
3706
3707 #endif /* CONFIG_POSIX */
3708
3709 #ifdef CONFIG_CIFS_ACL
3710 /*
3711 * Initialize NT TRANSACT SMB into small smb request buffer. This assumes that
3712 * all NT TRANSACTS that we init here have total parm and data under about 400
3713 * bytes (to fit in small cifs buffer size), which is the case so far, it
3714 * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3715 * returned setup area) and MaxParameterCount (returned parms size) must be set
3716 * by caller
3717 */
3718 static int
3719 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3720 const int parm_len, struct cifs_tcon *tcon,
3721 void **ret_buf)
3722 {
3723 int rc;
3724 __u32 temp_offset;
3725 struct smb_com_ntransact_req *pSMB;
3726
3727 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3728 (void **)&pSMB);
3729 if (rc)
3730 return rc;
3731 *ret_buf = (void *)pSMB;
3732 pSMB->Reserved = 0;
3733 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3734 pSMB->TotalDataCount = 0;
3735 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3736 pSMB->ParameterCount = pSMB->TotalParameterCount;
3737 pSMB->DataCount = pSMB->TotalDataCount;
3738 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3739 (setup_count * 2) - 4 /* for rfc1001 length itself */;
3740 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3741 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3742 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3743 pSMB->SubCommand = cpu_to_le16(sub_command);
3744 return 0;
3745 }
3746
3747 static int
3748 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3749 __u32 *pparmlen, __u32 *pdatalen)
3750 {
3751 char *end_of_smb;
3752 __u32 data_count, data_offset, parm_count, parm_offset;
3753 struct smb_com_ntransact_rsp *pSMBr;
3754 u16 bcc;
3755
3756 *pdatalen = 0;
3757 *pparmlen = 0;
3758
3759 if (buf == NULL)
3760 return -EINVAL;
3761
3762 pSMBr = (struct smb_com_ntransact_rsp *)buf;
3763
3764 bcc = get_bcc(&pSMBr->hdr);
3765 end_of_smb = 2 /* sizeof byte count */ + bcc +
3766 (char *)&pSMBr->ByteCount;
3767
3768 data_offset = le32_to_cpu(pSMBr->DataOffset);
3769 data_count = le32_to_cpu(pSMBr->DataCount);
3770 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3771 parm_count = le32_to_cpu(pSMBr->ParameterCount);
3772
3773 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3774 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3775
3776 /* should we also check that parm and data areas do not overlap? */
3777 if (*ppparm > end_of_smb) {
3778 cifs_dbg(FYI, "parms start after end of smb\n");
3779 return -EINVAL;
3780 } else if (parm_count + *ppparm > end_of_smb) {
3781 cifs_dbg(FYI, "parm end after end of smb\n");
3782 return -EINVAL;
3783 } else if (*ppdata > end_of_smb) {
3784 cifs_dbg(FYI, "data starts after end of smb\n");
3785 return -EINVAL;
3786 } else if (data_count + *ppdata > end_of_smb) {
3787 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3788 *ppdata, data_count, (data_count + *ppdata),
3789 end_of_smb, pSMBr);
3790 return -EINVAL;
3791 } else if (parm_count + data_count > bcc) {
3792 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
3793 return -EINVAL;
3794 }
3795 *pdatalen = data_count;
3796 *pparmlen = parm_count;
3797 return 0;
3798 }
3799
3800 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3801 int
3802 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3803 struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3804 {
3805 int rc = 0;
3806 int buf_type = 0;
3807 QUERY_SEC_DESC_REQ *pSMB;
3808 struct kvec iov[1];
3809
3810 cifs_dbg(FYI, "GetCifsACL\n");
3811
3812 *pbuflen = 0;
3813 *acl_inf = NULL;
3814
3815 rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3816 8 /* parm len */, tcon, (void **) &pSMB);
3817 if (rc)
3818 return rc;
3819
3820 pSMB->MaxParameterCount = cpu_to_le32(4);
3821 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3822 pSMB->MaxSetupCount = 0;
3823 pSMB->Fid = fid; /* file handle always le */
3824 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3825 CIFS_ACL_DACL);
3826 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3827 inc_rfc1001_len(pSMB, 11);
3828 iov[0].iov_base = (char *)pSMB;
3829 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3830
3831 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3832 0);
3833 cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3834 if (rc) {
3835 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
3836 } else { /* decode response */
3837 __le32 *parm;
3838 __u32 parm_len;
3839 __u32 acl_len;
3840 struct smb_com_ntransact_rsp *pSMBr;
3841 char *pdata;
3842
3843 /* validate_nttransact */
3844 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3845 &pdata, &parm_len, pbuflen);
3846 if (rc)
3847 goto qsec_out;
3848 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3849
3850 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3851 pSMBr, parm, *acl_inf);
3852
3853 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3854 rc = -EIO; /* bad smb */
3855 *pbuflen = 0;
3856 goto qsec_out;
3857 }
3858
3859 /* BB check that data area is minimum length and as big as acl_len */
3860
3861 acl_len = le32_to_cpu(*parm);
3862 if (acl_len != *pbuflen) {
3863 cifs_dbg(VFS, "acl length %d does not match %d\n",
3864 acl_len, *pbuflen);
3865 if (*pbuflen > acl_len)
3866 *pbuflen = acl_len;
3867 }
3868
3869 /* check if buffer is big enough for the acl
3870 header followed by the smallest SID */
3871 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3872 (*pbuflen >= 64 * 1024)) {
3873 cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
3874 rc = -EINVAL;
3875 *pbuflen = 0;
3876 } else {
3877 *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
3878 if (*acl_inf == NULL) {
3879 *pbuflen = 0;
3880 rc = -ENOMEM;
3881 }
3882 }
3883 }
3884 qsec_out:
3885 free_rsp_buf(buf_type, iov[0].iov_base);
3886 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3887 return rc;
3888 }
3889
3890 int
3891 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3892 struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
3893 {
3894 __u16 byte_count, param_count, data_count, param_offset, data_offset;
3895 int rc = 0;
3896 int bytes_returned = 0;
3897 SET_SEC_DESC_REQ *pSMB = NULL;
3898 void *pSMBr;
3899
3900 setCifsAclRetry:
3901 rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
3902 if (rc)
3903 return rc;
3904
3905 pSMB->MaxSetupCount = 0;
3906 pSMB->Reserved = 0;
3907
3908 param_count = 8;
3909 param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3910 data_count = acllen;
3911 data_offset = param_offset + param_count;
3912 byte_count = 3 /* pad */ + param_count;
3913
3914 pSMB->DataCount = cpu_to_le32(data_count);
3915 pSMB->TotalDataCount = pSMB->DataCount;
3916 pSMB->MaxParameterCount = cpu_to_le32(4);
3917 pSMB->MaxDataCount = cpu_to_le32(16384);
3918 pSMB->ParameterCount = cpu_to_le32(param_count);
3919 pSMB->ParameterOffset = cpu_to_le32(param_offset);
3920 pSMB->TotalParameterCount = pSMB->ParameterCount;
3921 pSMB->DataOffset = cpu_to_le32(data_offset);
3922 pSMB->SetupCount = 0;
3923 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3924 pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3925
3926 pSMB->Fid = fid; /* file handle always le */
3927 pSMB->Reserved2 = 0;
3928 pSMB->AclFlags = cpu_to_le32(aclflag);
3929
3930 if (pntsd && acllen) {
3931 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
3932 data_offset, pntsd, acllen);
3933 inc_rfc1001_len(pSMB, byte_count + data_count);
3934 } else
3935 inc_rfc1001_len(pSMB, byte_count);
3936
3937 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3938 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3939
3940 cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
3941 bytes_returned, rc);
3942 if (rc)
3943 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
3944 cifs_buf_release(pSMB);
3945
3946 if (rc == -EAGAIN)
3947 goto setCifsAclRetry;
3948
3949 return (rc);
3950 }
3951
3952 #endif /* CONFIG_CIFS_ACL */
3953
3954 /* Legacy Query Path Information call for lookup to old servers such
3955 as Win9x/WinME */
3956 int
3957 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
3958 const char *search_name, FILE_ALL_INFO *data,
3959 const struct nls_table *nls_codepage, int remap)
3960 {
3961 QUERY_INFORMATION_REQ *pSMB;
3962 QUERY_INFORMATION_RSP *pSMBr;
3963 int rc = 0;
3964 int bytes_returned;
3965 int name_len;
3966
3967 cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
3968 QInfRetry:
3969 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3970 (void **) &pSMBr);
3971 if (rc)
3972 return rc;
3973
3974 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3975 name_len =
3976 cifsConvertToUTF16((__le16 *) pSMB->FileName,
3977 search_name, PATH_MAX, nls_codepage,
3978 remap);
3979 name_len++; /* trailing null */
3980 name_len *= 2;
3981 } else {
3982 name_len = strnlen(search_name, PATH_MAX);
3983 name_len++; /* trailing null */
3984 strncpy(pSMB->FileName, search_name, name_len);
3985 }
3986 pSMB->BufferFormat = 0x04;
3987 name_len++; /* account for buffer type byte */
3988 inc_rfc1001_len(pSMB, (__u16)name_len);
3989 pSMB->ByteCount = cpu_to_le16(name_len);
3990
3991 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3992 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3993 if (rc) {
3994 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
3995 } else if (data) {
3996 struct timespec ts;
3997 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3998
3999 /* decode response */
4000 /* BB FIXME - add time zone adjustment BB */
4001 memset(data, 0, sizeof(FILE_ALL_INFO));
4002 ts.tv_nsec = 0;
4003 ts.tv_sec = time;
4004 /* decode time fields */
4005 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
4006 data->LastWriteTime = data->ChangeTime;
4007 data->LastAccessTime = 0;
4008 data->AllocationSize =
4009 cpu_to_le64(le32_to_cpu(pSMBr->size));
4010 data->EndOfFile = data->AllocationSize;
4011 data->Attributes =
4012 cpu_to_le32(le16_to_cpu(pSMBr->attr));
4013 } else
4014 rc = -EIO; /* bad buffer passed in */
4015
4016 cifs_buf_release(pSMB);
4017
4018 if (rc == -EAGAIN)
4019 goto QInfRetry;
4020
4021 return rc;
4022 }
4023
4024 int
4025 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
4026 u16 netfid, FILE_ALL_INFO *pFindData)
4027 {
4028 struct smb_t2_qfi_req *pSMB = NULL;
4029 struct smb_t2_qfi_rsp *pSMBr = NULL;
4030 int rc = 0;
4031 int bytes_returned;
4032 __u16 params, byte_count;
4033
4034 QFileInfoRetry:
4035 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4036 (void **) &pSMBr);
4037 if (rc)
4038 return rc;
4039
4040 params = 2 /* level */ + 2 /* fid */;
4041 pSMB->t2.TotalDataCount = 0;
4042 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4043 /* BB find exact max data count below from sess structure BB */
4044 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4045 pSMB->t2.MaxSetupCount = 0;
4046 pSMB->t2.Reserved = 0;
4047 pSMB->t2.Flags = 0;
4048 pSMB->t2.Timeout = 0;
4049 pSMB->t2.Reserved2 = 0;
4050 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4051 Fid) - 4);
4052 pSMB->t2.DataCount = 0;
4053 pSMB->t2.DataOffset = 0;
4054 pSMB->t2.SetupCount = 1;
4055 pSMB->t2.Reserved3 = 0;
4056 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4057 byte_count = params + 1 /* pad */ ;
4058 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4059 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4060 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4061 pSMB->Pad = 0;
4062 pSMB->Fid = netfid;
4063 inc_rfc1001_len(pSMB, byte_count);
4064 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
4065
4066 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4067 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4068 if (rc) {
4069 cifs_dbg(FYI, "Send error in QFileInfo = %d", rc);
4070 } else { /* decode response */
4071 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4072
4073 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4074 rc = -EIO;
4075 else if (get_bcc(&pSMBr->hdr) < 40)
4076 rc = -EIO; /* bad smb */
4077 else if (pFindData) {
4078 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4079 memcpy((char *) pFindData,
4080 (char *) &pSMBr->hdr.Protocol +
4081 data_offset, sizeof(FILE_ALL_INFO));
4082 } else
4083 rc = -ENOMEM;
4084 }
4085 cifs_buf_release(pSMB);
4086 if (rc == -EAGAIN)
4087 goto QFileInfoRetry;
4088
4089 return rc;
4090 }
4091
4092 int
4093 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
4094 const char *search_name, FILE_ALL_INFO *data,
4095 int legacy /* old style infolevel */,
4096 const struct nls_table *nls_codepage, int remap)
4097 {
4098 /* level 263 SMB_QUERY_FILE_ALL_INFO */
4099 TRANSACTION2_QPI_REQ *pSMB = NULL;
4100 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4101 int rc = 0;
4102 int bytes_returned;
4103 int name_len;
4104 __u16 params, byte_count;
4105
4106 /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
4107 QPathInfoRetry:
4108 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4109 (void **) &pSMBr);
4110 if (rc)
4111 return rc;
4112
4113 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4114 name_len =
4115 cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
4116 PATH_MAX, nls_codepage, remap);
4117 name_len++; /* trailing null */
4118 name_len *= 2;
4119 } else { /* BB improve the check for buffer overruns BB */
4120 name_len = strnlen(search_name, PATH_MAX);
4121 name_len++; /* trailing null */
4122 strncpy(pSMB->FileName, search_name, name_len);
4123 }
4124
4125 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4126 pSMB->TotalDataCount = 0;
4127 pSMB->MaxParameterCount = cpu_to_le16(2);
4128 /* BB find exact max SMB PDU from sess structure BB */
4129 pSMB->MaxDataCount = cpu_to_le16(4000);
4130 pSMB->MaxSetupCount = 0;
4131 pSMB->Reserved = 0;
4132 pSMB->Flags = 0;
4133 pSMB->Timeout = 0;
4134 pSMB->Reserved2 = 0;
4135 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4136 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4137 pSMB->DataCount = 0;
4138 pSMB->DataOffset = 0;
4139 pSMB->SetupCount = 1;
4140 pSMB->Reserved3 = 0;
4141 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4142 byte_count = params + 1 /* pad */ ;
4143 pSMB->TotalParameterCount = cpu_to_le16(params);
4144 pSMB->ParameterCount = pSMB->TotalParameterCount;
4145 if (legacy)
4146 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4147 else
4148 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4149 pSMB->Reserved4 = 0;
4150 inc_rfc1001_len(pSMB, byte_count);
4151 pSMB->ByteCount = cpu_to_le16(byte_count);
4152
4153 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4154 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4155 if (rc) {
4156 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
4157 } else { /* decode response */
4158 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4159
4160 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4161 rc = -EIO;
4162 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
4163 rc = -EIO; /* bad smb */
4164 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
4165 rc = -EIO; /* 24 or 26 expected but we do not read
4166 last field */
4167 else if (data) {
4168 int size;
4169 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4170
4171 /*
4172 * On legacy responses we do not read the last field,
4173 * EAsize, fortunately since it varies by subdialect and
4174 * also note it differs on Set vs Get, ie two bytes or 4
4175 * bytes depending but we don't care here.
4176 */
4177 if (legacy)
4178 size = sizeof(FILE_INFO_STANDARD);
4179 else
4180 size = sizeof(FILE_ALL_INFO);
4181 memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
4182 data_offset, size);
4183 } else
4184 rc = -ENOMEM;
4185 }
4186 cifs_buf_release(pSMB);
4187 if (rc == -EAGAIN)
4188 goto QPathInfoRetry;
4189
4190 return rc;
4191 }
4192
4193 int
4194 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
4195 u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4196 {
4197 struct smb_t2_qfi_req *pSMB = NULL;
4198 struct smb_t2_qfi_rsp *pSMBr = NULL;
4199 int rc = 0;
4200 int bytes_returned;
4201 __u16 params, byte_count;
4202
4203 UnixQFileInfoRetry:
4204 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4205 (void **) &pSMBr);
4206 if (rc)
4207 return rc;
4208
4209 params = 2 /* level */ + 2 /* fid */;
4210 pSMB->t2.TotalDataCount = 0;
4211 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4212 /* BB find exact max data count below from sess structure BB */
4213 pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4214 pSMB->t2.MaxSetupCount = 0;
4215 pSMB->t2.Reserved = 0;
4216 pSMB->t2.Flags = 0;
4217 pSMB->t2.Timeout = 0;
4218 pSMB->t2.Reserved2 = 0;
4219 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4220 Fid) - 4);
4221 pSMB->t2.DataCount = 0;
4222 pSMB->t2.DataOffset = 0;
4223 pSMB->t2.SetupCount = 1;
4224 pSMB->t2.Reserved3 = 0;
4225 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4226 byte_count = params + 1 /* pad */ ;
4227 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4228 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4229 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4230 pSMB->Pad = 0;
4231 pSMB->Fid = netfid;
4232 inc_rfc1001_len(pSMB, byte_count);
4233 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
4234
4235 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4236 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4237 if (rc) {
4238 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d", rc);
4239 } else { /* decode response */
4240 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4241
4242 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4243 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4244 rc = -EIO; /* bad smb */
4245 } else {
4246 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4247 memcpy((char *) pFindData,
4248 (char *) &pSMBr->hdr.Protocol +
4249 data_offset,
4250 sizeof(FILE_UNIX_BASIC_INFO));
4251 }
4252 }
4253
4254 cifs_buf_release(pSMB);
4255 if (rc == -EAGAIN)
4256 goto UnixQFileInfoRetry;
4257
4258 return rc;
4259 }
4260
4261 int
4262 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
4263 const unsigned char *searchName,
4264 FILE_UNIX_BASIC_INFO *pFindData,
4265 const struct nls_table *nls_codepage, int remap)
4266 {
4267 /* SMB_QUERY_FILE_UNIX_BASIC */
4268 TRANSACTION2_QPI_REQ *pSMB = NULL;
4269 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4270 int rc = 0;
4271 int bytes_returned = 0;
4272 int name_len;
4273 __u16 params, byte_count;
4274
4275 cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
4276 UnixQPathInfoRetry:
4277 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4278 (void **) &pSMBr);
4279 if (rc)
4280 return rc;
4281
4282 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4283 name_len =
4284 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4285 PATH_MAX, nls_codepage, remap);
4286 name_len++; /* trailing null */
4287 name_len *= 2;
4288 } else { /* BB improve the check for buffer overruns BB */
4289 name_len = strnlen(searchName, PATH_MAX);
4290 name_len++; /* trailing null */
4291 strncpy(pSMB->FileName, searchName, name_len);
4292 }
4293
4294 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4295 pSMB->TotalDataCount = 0;
4296 pSMB->MaxParameterCount = cpu_to_le16(2);
4297 /* BB find exact max SMB PDU from sess structure BB */
4298 pSMB->MaxDataCount = cpu_to_le16(4000);
4299 pSMB->MaxSetupCount = 0;
4300 pSMB->Reserved = 0;
4301 pSMB->Flags = 0;
4302 pSMB->Timeout = 0;
4303 pSMB->Reserved2 = 0;
4304 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4305 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4306 pSMB->DataCount = 0;
4307 pSMB->DataOffset = 0;
4308 pSMB->SetupCount = 1;
4309 pSMB->Reserved3 = 0;
4310 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4311 byte_count = params + 1 /* pad */ ;
4312 pSMB->TotalParameterCount = cpu_to_le16(params);
4313 pSMB->ParameterCount = pSMB->TotalParameterCount;
4314 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4315 pSMB->Reserved4 = 0;
4316 inc_rfc1001_len(pSMB, byte_count);
4317 pSMB->ByteCount = cpu_to_le16(byte_count);
4318
4319 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4320 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4321 if (rc) {
4322 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d", rc);
4323 } else { /* decode response */
4324 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4325
4326 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4327 cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4328 rc = -EIO; /* bad smb */
4329 } else {
4330 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4331 memcpy((char *) pFindData,
4332 (char *) &pSMBr->hdr.Protocol +
4333 data_offset,
4334 sizeof(FILE_UNIX_BASIC_INFO));
4335 }
4336 }
4337 cifs_buf_release(pSMB);
4338 if (rc == -EAGAIN)
4339 goto UnixQPathInfoRetry;
4340
4341 return rc;
4342 }
4343
4344 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4345 int
4346 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
4347 const char *searchName, struct cifs_sb_info *cifs_sb,
4348 __u16 *pnetfid, __u16 search_flags,
4349 struct cifs_search_info *psrch_inf, bool msearch)
4350 {
4351 /* level 257 SMB_ */
4352 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4353 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
4354 T2_FFIRST_RSP_PARMS *parms;
4355 int rc = 0;
4356 int bytes_returned = 0;
4357 int name_len, remap;
4358 __u16 params, byte_count;
4359 struct nls_table *nls_codepage;
4360
4361 cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
4362
4363 findFirstRetry:
4364 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4365 (void **) &pSMBr);
4366 if (rc)
4367 return rc;
4368
4369 nls_codepage = cifs_sb->local_nls;
4370 remap = cifs_remap(cifs_sb);
4371
4372 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4373 name_len =
4374 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4375 PATH_MAX, nls_codepage, remap);
4376 /* We can not add the asterik earlier in case
4377 it got remapped to 0xF03A as if it were part of the
4378 directory name instead of a wildcard */
4379 name_len *= 2;
4380 if (msearch) {
4381 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4382 pSMB->FileName[name_len+1] = 0;
4383 pSMB->FileName[name_len+2] = '*';
4384 pSMB->FileName[name_len+3] = 0;
4385 name_len += 4; /* now the trailing null */
4386 /* null terminate just in case */
4387 pSMB->FileName[name_len] = 0;
4388 pSMB->FileName[name_len+1] = 0;
4389 name_len += 2;
4390 }
4391 } else { /* BB add check for overrun of SMB buf BB */
4392 name_len = strnlen(searchName, PATH_MAX);
4393 /* BB fix here and in unicode clause above ie
4394 if (name_len > buffersize-header)
4395 free buffer exit; BB */
4396 strncpy(pSMB->FileName, searchName, name_len);
4397 if (msearch) {
4398 pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4399 pSMB->FileName[name_len+1] = '*';
4400 pSMB->FileName[name_len+2] = 0;
4401 name_len += 3;
4402 }
4403 }
4404
4405 params = 12 + name_len /* includes null */ ;
4406 pSMB->TotalDataCount = 0; /* no EAs */
4407 pSMB->MaxParameterCount = cpu_to_le16(10);
4408 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4409 pSMB->MaxSetupCount = 0;
4410 pSMB->Reserved = 0;
4411 pSMB->Flags = 0;
4412 pSMB->Timeout = 0;
4413 pSMB->Reserved2 = 0;
4414 byte_count = params + 1 /* pad */ ;
4415 pSMB->TotalParameterCount = cpu_to_le16(params);
4416 pSMB->ParameterCount = pSMB->TotalParameterCount;
4417 pSMB->ParameterOffset = cpu_to_le16(
4418 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4419 - 4);
4420 pSMB->DataCount = 0;
4421 pSMB->DataOffset = 0;
4422 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
4423 pSMB->Reserved3 = 0;
4424 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4425 pSMB->SearchAttributes =
4426 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4427 ATTR_DIRECTORY);
4428 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4429 pSMB->SearchFlags = cpu_to_le16(search_flags);
4430 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4431
4432 /* BB what should we set StorageType to? Does it matter? BB */
4433 pSMB->SearchStorageType = 0;
4434 inc_rfc1001_len(pSMB, byte_count);
4435 pSMB->ByteCount = cpu_to_le16(byte_count);
4436
4437 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4438 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4439 cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
4440
4441 if (rc) {/* BB add logic to retry regular search if Unix search
4442 rejected unexpectedly by server */
4443 /* BB Add code to handle unsupported level rc */
4444 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
4445
4446 cifs_buf_release(pSMB);
4447
4448 /* BB eventually could optimize out free and realloc of buf */
4449 /* for this case */
4450 if (rc == -EAGAIN)
4451 goto findFirstRetry;
4452 } else { /* decode response */
4453 /* BB remember to free buffer if error BB */
4454 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4455 if (rc == 0) {
4456 unsigned int lnoff;
4457
4458 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4459 psrch_inf->unicode = true;
4460 else
4461 psrch_inf->unicode = false;
4462
4463 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4464 psrch_inf->smallBuf = 0;
4465 psrch_inf->srch_entries_start =
4466 (char *) &pSMBr->hdr.Protocol +
4467 le16_to_cpu(pSMBr->t2.DataOffset);
4468 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4469 le16_to_cpu(pSMBr->t2.ParameterOffset));
4470
4471 if (parms->EndofSearch)
4472 psrch_inf->endOfSearch = true;
4473 else
4474 psrch_inf->endOfSearch = false;
4475
4476 psrch_inf->entries_in_buffer =
4477 le16_to_cpu(parms->SearchCount);
4478 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4479 psrch_inf->entries_in_buffer;
4480 lnoff = le16_to_cpu(parms->LastNameOffset);
4481 if (CIFSMaxBufSize < lnoff) {
4482 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4483 psrch_inf->last_entry = NULL;
4484 return rc;
4485 }
4486
4487 psrch_inf->last_entry = psrch_inf->srch_entries_start +
4488 lnoff;
4489
4490 if (pnetfid)
4491 *pnetfid = parms->SearchHandle;
4492 } else {
4493 cifs_buf_release(pSMB);
4494 }
4495 }
4496
4497 return rc;
4498 }
4499
4500 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4501 __u16 searchHandle, __u16 search_flags,
4502 struct cifs_search_info *psrch_inf)
4503 {
4504 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4505 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4506 T2_FNEXT_RSP_PARMS *parms;
4507 char *response_data;
4508 int rc = 0;
4509 int bytes_returned;
4510 unsigned int name_len;
4511 __u16 params, byte_count;
4512
4513 cifs_dbg(FYI, "In FindNext\n");
4514
4515 if (psrch_inf->endOfSearch)
4516 return -ENOENT;
4517
4518 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4519 (void **) &pSMBr);
4520 if (rc)
4521 return rc;
4522
4523 params = 14; /* includes 2 bytes of null string, converted to LE below*/
4524 byte_count = 0;
4525 pSMB->TotalDataCount = 0; /* no EAs */
4526 pSMB->MaxParameterCount = cpu_to_le16(8);
4527 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4528 pSMB->MaxSetupCount = 0;
4529 pSMB->Reserved = 0;
4530 pSMB->Flags = 0;
4531 pSMB->Timeout = 0;
4532 pSMB->Reserved2 = 0;
4533 pSMB->ParameterOffset = cpu_to_le16(
4534 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4535 pSMB->DataCount = 0;
4536 pSMB->DataOffset = 0;
4537 pSMB->SetupCount = 1;
4538 pSMB->Reserved3 = 0;
4539 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4540 pSMB->SearchHandle = searchHandle; /* always kept as le */
4541 pSMB->SearchCount =
4542 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4543 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4544 pSMB->ResumeKey = psrch_inf->resume_key;
4545 pSMB->SearchFlags = cpu_to_le16(search_flags);
4546
4547 name_len = psrch_inf->resume_name_len;
4548 params += name_len;
4549 if (name_len < PATH_MAX) {
4550 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4551 byte_count += name_len;
4552 /* 14 byte parm len above enough for 2 byte null terminator */
4553 pSMB->ResumeFileName[name_len] = 0;
4554 pSMB->ResumeFileName[name_len+1] = 0;
4555 } else {
4556 rc = -EINVAL;
4557 goto FNext2_err_exit;
4558 }
4559 byte_count = params + 1 /* pad */ ;
4560 pSMB->TotalParameterCount = cpu_to_le16(params);
4561 pSMB->ParameterCount = pSMB->TotalParameterCount;
4562 inc_rfc1001_len(pSMB, byte_count);
4563 pSMB->ByteCount = cpu_to_le16(byte_count);
4564
4565 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4566 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4567 cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
4568 if (rc) {
4569 if (rc == -EBADF) {
4570 psrch_inf->endOfSearch = true;
4571 cifs_buf_release(pSMB);
4572 rc = 0; /* search probably was closed at end of search*/
4573 } else
4574 cifs_dbg(FYI, "FindNext returned = %d\n", rc);
4575 } else { /* decode response */
4576 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4577
4578 if (rc == 0) {
4579 unsigned int lnoff;
4580
4581 /* BB fixme add lock for file (srch_info) struct here */
4582 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4583 psrch_inf->unicode = true;
4584 else
4585 psrch_inf->unicode = false;
4586 response_data = (char *) &pSMBr->hdr.Protocol +
4587 le16_to_cpu(pSMBr->t2.ParameterOffset);
4588 parms = (T2_FNEXT_RSP_PARMS *)response_data;
4589 response_data = (char *)&pSMBr->hdr.Protocol +
4590 le16_to_cpu(pSMBr->t2.DataOffset);
4591 if (psrch_inf->smallBuf)
4592 cifs_small_buf_release(
4593 psrch_inf->ntwrk_buf_start);
4594 else
4595 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4596 psrch_inf->srch_entries_start = response_data;
4597 psrch_inf->ntwrk_buf_start = (char *)pSMB;
4598 psrch_inf->smallBuf = 0;
4599 if (parms->EndofSearch)
4600 psrch_inf->endOfSearch = true;
4601 else
4602 psrch_inf->endOfSearch = false;
4603 psrch_inf->entries_in_buffer =
4604 le16_to_cpu(parms->SearchCount);
4605 psrch_inf->index_of_last_entry +=
4606 psrch_inf->entries_in_buffer;
4607 lnoff = le16_to_cpu(parms->LastNameOffset);
4608 if (CIFSMaxBufSize < lnoff) {
4609 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4610 psrch_inf->last_entry = NULL;
4611 return rc;
4612 } else
4613 psrch_inf->last_entry =
4614 psrch_inf->srch_entries_start + lnoff;
4615
4616 /* cifs_dbg(FYI, "fnxt2 entries in buf %d index_of_last %d\n",
4617 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4618
4619 /* BB fixme add unlock here */
4620 }
4621
4622 }
4623
4624 /* BB On error, should we leave previous search buf (and count and
4625 last entry fields) intact or free the previous one? */
4626
4627 /* Note: On -EAGAIN error only caller can retry on handle based calls
4628 since file handle passed in no longer valid */
4629 FNext2_err_exit:
4630 if (rc != 0)
4631 cifs_buf_release(pSMB);
4632 return rc;
4633 }
4634
4635 int
4636 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
4637 const __u16 searchHandle)
4638 {
4639 int rc = 0;
4640 FINDCLOSE_REQ *pSMB = NULL;
4641
4642 cifs_dbg(FYI, "In CIFSSMBFindClose\n");
4643 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4644
4645 /* no sense returning error if session restarted
4646 as file handle has been closed */
4647 if (rc == -EAGAIN)
4648 return 0;
4649 if (rc)
4650 return rc;
4651
4652 pSMB->FileID = searchHandle;
4653 pSMB->ByteCount = 0;
4654 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4655 if (rc)
4656 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
4657
4658 cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
4659
4660 /* Since session is dead, search handle closed on server already */
4661 if (rc == -EAGAIN)
4662 rc = 0;
4663
4664 return rc;
4665 }
4666
4667 int
4668 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
4669 const char *search_name, __u64 *inode_number,
4670 const struct nls_table *nls_codepage, int remap)
4671 {
4672 int rc = 0;
4673 TRANSACTION2_QPI_REQ *pSMB = NULL;
4674 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4675 int name_len, bytes_returned;
4676 __u16 params, byte_count;
4677
4678 cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
4679 if (tcon == NULL)
4680 return -ENODEV;
4681
4682 GetInodeNumberRetry:
4683 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4684 (void **) &pSMBr);
4685 if (rc)
4686 return rc;
4687
4688 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4689 name_len =
4690 cifsConvertToUTF16((__le16 *) pSMB->FileName,
4691 search_name, PATH_MAX, nls_codepage,
4692 remap);
4693 name_len++; /* trailing null */
4694 name_len *= 2;
4695 } else { /* BB improve the check for buffer overruns BB */
4696 name_len = strnlen(search_name, PATH_MAX);
4697 name_len++; /* trailing null */
4698 strncpy(pSMB->FileName, search_name, name_len);
4699 }
4700
4701 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
4702 pSMB->TotalDataCount = 0;
4703 pSMB->MaxParameterCount = cpu_to_le16(2);
4704 /* BB find exact max data count below from sess structure BB */
4705 pSMB->MaxDataCount = cpu_to_le16(4000);
4706 pSMB->MaxSetupCount = 0;
4707 pSMB->Reserved = 0;
4708 pSMB->Flags = 0;
4709 pSMB->Timeout = 0;
4710 pSMB->Reserved2 = 0;
4711 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4712 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4713 pSMB->DataCount = 0;
4714 pSMB->DataOffset = 0;
4715 pSMB->SetupCount = 1;
4716 pSMB->Reserved3 = 0;
4717 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4718 byte_count = params + 1 /* pad */ ;
4719 pSMB->TotalParameterCount = cpu_to_le16(params);
4720 pSMB->ParameterCount = pSMB->TotalParameterCount;
4721 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4722 pSMB->Reserved4 = 0;
4723 inc_rfc1001_len(pSMB, byte_count);
4724 pSMB->ByteCount = cpu_to_le16(byte_count);
4725
4726 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4727 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4728 if (rc) {
4729 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
4730 } else {
4731 /* decode response */
4732 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4733 /* BB also check enough total bytes returned */
4734 if (rc || get_bcc(&pSMBr->hdr) < 2)
4735 /* If rc should we check for EOPNOSUPP and
4736 disable the srvino flag? or in caller? */
4737 rc = -EIO; /* bad smb */
4738 else {
4739 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4740 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4741 struct file_internal_info *pfinfo;
4742 /* BB Do we need a cast or hash here ? */
4743 if (count < 8) {
4744 cifs_dbg(FYI, "Illegal size ret in QryIntrnlInf\n");
4745 rc = -EIO;
4746 goto GetInodeNumOut;
4747 }
4748 pfinfo = (struct file_internal_info *)
4749 (data_offset + (char *) &pSMBr->hdr.Protocol);
4750 *inode_number = le64_to_cpu(pfinfo->UniqueId);
4751 }
4752 }
4753 GetInodeNumOut:
4754 cifs_buf_release(pSMB);
4755 if (rc == -EAGAIN)
4756 goto GetInodeNumberRetry;
4757 return rc;
4758 }
4759
4760 /* parses DFS refferal V3 structure
4761 * caller is responsible for freeing target_nodes
4762 * returns:
4763 * on success - 0
4764 * on failure - errno
4765 */
4766 static int
4767 parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
4768 unsigned int *num_of_nodes,
4769 struct dfs_info3_param **target_nodes,
4770 const struct nls_table *nls_codepage, int remap,
4771 const char *searchName)
4772 {
4773 int i, rc = 0;
4774 char *data_end;
4775 bool is_unicode;
4776 struct dfs_referral_level_3 *ref;
4777
4778 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4779 is_unicode = true;
4780 else
4781 is_unicode = false;
4782 *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
4783
4784 if (*num_of_nodes < 1) {
4785 cifs_dbg(VFS, "num_referrals: must be at least > 0, but we get num_referrals = %d\n",
4786 *num_of_nodes);
4787 rc = -EINVAL;
4788 goto parse_DFS_referrals_exit;
4789 }
4790
4791 ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
4792 if (ref->VersionNumber != cpu_to_le16(3)) {
4793 cifs_dbg(VFS, "Referrals of V%d version are not supported, should be V3\n",
4794 le16_to_cpu(ref->VersionNumber));
4795 rc = -EINVAL;
4796 goto parse_DFS_referrals_exit;
4797 }
4798
4799 /* get the upper boundary of the resp buffer */
4800 data_end = (char *)(&(pSMBr->PathConsumed)) +
4801 le16_to_cpu(pSMBr->t2.DataCount);
4802
4803 cifs_dbg(FYI, "num_referrals: %d dfs flags: 0x%x ...\n",
4804 *num_of_nodes, le32_to_cpu(pSMBr->DFSFlags));
4805
4806 *target_nodes = kcalloc(*num_of_nodes, sizeof(struct dfs_info3_param),
4807 GFP_KERNEL);
4808 if (*target_nodes == NULL) {
4809 rc = -ENOMEM;
4810 goto parse_DFS_referrals_exit;
4811 }
4812
4813 /* collect necessary data from referrals */
4814 for (i = 0; i < *num_of_nodes; i++) {
4815 char *temp;
4816 int max_len;
4817 struct dfs_info3_param *node = (*target_nodes)+i;
4818
4819 node->flags = le32_to_cpu(pSMBr->DFSFlags);
4820 if (is_unicode) {
4821 __le16 *tmp = kmalloc(strlen(searchName)*2 + 2,
4822 GFP_KERNEL);
4823 if (tmp == NULL) {
4824 rc = -ENOMEM;
4825 goto parse_DFS_referrals_exit;
4826 }
4827 cifsConvertToUTF16((__le16 *) tmp, searchName,
4828 PATH_MAX, nls_codepage, remap);
4829 node->path_consumed = cifs_utf16_bytes(tmp,
4830 le16_to_cpu(pSMBr->PathConsumed),
4831 nls_codepage);
4832 kfree(tmp);
4833 } else
4834 node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
4835
4836 node->server_type = le16_to_cpu(ref->ServerType);
4837 node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
4838
4839 /* copy DfsPath */
4840 temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
4841 max_len = data_end - temp;
4842 node->path_name = cifs_strndup_from_utf16(temp, max_len,
4843 is_unicode, nls_codepage);
4844 if (!node->path_name) {
4845 rc = -ENOMEM;
4846 goto parse_DFS_referrals_exit;
4847 }
4848
4849 /* copy link target UNC */
4850 temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
4851 max_len = data_end - temp;
4852 node->node_name = cifs_strndup_from_utf16(temp, max_len,
4853 is_unicode, nls_codepage);
4854 if (!node->node_name) {
4855 rc = -ENOMEM;
4856 goto parse_DFS_referrals_exit;
4857 }
4858
4859 ref++;
4860 }
4861
4862 parse_DFS_referrals_exit:
4863 if (rc) {
4864 free_dfs_info_array(*target_nodes, *num_of_nodes);
4865 *target_nodes = NULL;
4866 *num_of_nodes = 0;
4867 }
4868 return rc;
4869 }
4870
4871 int
4872 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
4873 const char *search_name, struct dfs_info3_param **target_nodes,
4874 unsigned int *num_of_nodes,
4875 const struct nls_table *nls_codepage, int remap)
4876 {
4877 /* TRANS2_GET_DFS_REFERRAL */
4878 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4879 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4880 int rc = 0;
4881 int bytes_returned;
4882 int name_len;
4883 __u16 params, byte_count;
4884 *num_of_nodes = 0;
4885 *target_nodes = NULL;
4886
4887 cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
4888 if (ses == NULL)
4889 return -ENODEV;
4890 getDFSRetry:
4891 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
4892 (void **) &pSMBr);
4893 if (rc)
4894 return rc;
4895
4896 /* server pointer checked in called function,
4897 but should never be null here anyway */
4898 pSMB->hdr.Mid = get_next_mid(ses->server);
4899 pSMB->hdr.Tid = ses->ipc_tid;
4900 pSMB->hdr.Uid = ses->Suid;
4901 if (ses->capabilities & CAP_STATUS32)
4902 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4903 if (ses->capabilities & CAP_DFS)
4904 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4905
4906 if (ses->capabilities & CAP_UNICODE) {
4907 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4908 name_len =
4909 cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4910 search_name, PATH_MAX, nls_codepage,
4911 remap);
4912 name_len++; /* trailing null */
4913 name_len *= 2;
4914 } else { /* BB improve the check for buffer overruns BB */
4915 name_len = strnlen(search_name, PATH_MAX);
4916 name_len++; /* trailing null */
4917 strncpy(pSMB->RequestFileName, search_name, name_len);
4918 }
4919
4920 if (ses->server->sign)
4921 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4922
4923 pSMB->hdr.Uid = ses->Suid;
4924
4925 params = 2 /* level */ + name_len /*includes null */ ;
4926 pSMB->TotalDataCount = 0;
4927 pSMB->DataCount = 0;
4928 pSMB->DataOffset = 0;
4929 pSMB->MaxParameterCount = 0;
4930 /* BB find exact max SMB PDU from sess structure BB */
4931 pSMB->MaxDataCount = cpu_to_le16(4000);
4932 pSMB->MaxSetupCount = 0;
4933 pSMB->Reserved = 0;
4934 pSMB->Flags = 0;
4935 pSMB->Timeout = 0;
4936 pSMB->Reserved2 = 0;
4937 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4938 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4939 pSMB->SetupCount = 1;
4940 pSMB->Reserved3 = 0;
4941 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4942 byte_count = params + 3 /* pad */ ;
4943 pSMB->ParameterCount = cpu_to_le16(params);
4944 pSMB->TotalParameterCount = pSMB->ParameterCount;
4945 pSMB->MaxReferralLevel = cpu_to_le16(3);
4946 inc_rfc1001_len(pSMB, byte_count);
4947 pSMB->ByteCount = cpu_to_le16(byte_count);
4948
4949 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4950 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4951 if (rc) {
4952 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
4953 goto GetDFSRefExit;
4954 }
4955 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4956
4957 /* BB Also check if enough total bytes returned? */
4958 if (rc || get_bcc(&pSMBr->hdr) < 17) {
4959 rc = -EIO; /* bad smb */
4960 goto GetDFSRefExit;
4961 }
4962
4963 cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d Offset %d\n",
4964 get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
4965
4966 /* parse returned result into more usable form */
4967 rc = parse_DFS_referrals(pSMBr, num_of_nodes,
4968 target_nodes, nls_codepage, remap,
4969 search_name);
4970
4971 GetDFSRefExit:
4972 cifs_buf_release(pSMB);
4973
4974 if (rc == -EAGAIN)
4975 goto getDFSRetry;
4976
4977 return rc;
4978 }
4979
4980 /* Query File System Info such as free space to old servers such as Win 9x */
4981 int
4982 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4983 struct kstatfs *FSData)
4984 {
4985 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4986 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4987 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4988 FILE_SYSTEM_ALLOC_INFO *response_data;
4989 int rc = 0;
4990 int bytes_returned = 0;
4991 __u16 params, byte_count;
4992
4993 cifs_dbg(FYI, "OldQFSInfo\n");
4994 oldQFSInfoRetry:
4995 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4996 (void **) &pSMBr);
4997 if (rc)
4998 return rc;
4999
5000 params = 2; /* level */
5001 pSMB->TotalDataCount = 0;
5002 pSMB->MaxParameterCount = cpu_to_le16(2);
5003 pSMB->MaxDataCount = cpu_to_le16(1000);
5004 pSMB->MaxSetupCount = 0;
5005 pSMB->Reserved = 0;
5006 pSMB->Flags = 0;
5007 pSMB->Timeout = 0;
5008 pSMB->Reserved2 = 0;
5009 byte_count = params + 1 /* pad */ ;
5010 pSMB->TotalParameterCount = cpu_to_le16(params);
5011 pSMB->ParameterCount = pSMB->TotalParameterCount;
5012 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5013 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5014 pSMB->DataCount = 0;
5015 pSMB->DataOffset = 0;
5016 pSMB->SetupCount = 1;
5017 pSMB->Reserved3 = 0;
5018 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5019 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
5020 inc_rfc1001_len(pSMB, byte_count);
5021 pSMB->ByteCount = cpu_to_le16(byte_count);
5022
5023 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5024 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5025 if (rc) {
5026 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
5027 } else { /* decode response */
5028 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5029
5030 if (rc || get_bcc(&pSMBr->hdr) < 18)
5031 rc = -EIO; /* bad smb */
5032 else {
5033 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5034 cifs_dbg(FYI, "qfsinf resp BCC: %d Offset %d\n",
5035 get_bcc(&pSMBr->hdr), data_offset);
5036
5037 response_data = (FILE_SYSTEM_ALLOC_INFO *)
5038 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5039 FSData->f_bsize =
5040 le16_to_cpu(response_data->BytesPerSector) *
5041 le32_to_cpu(response_data->
5042 SectorsPerAllocationUnit);
5043 FSData->f_blocks =
5044 le32_to_cpu(response_data->TotalAllocationUnits);
5045 FSData->f_bfree = FSData->f_bavail =
5046 le32_to_cpu(response_data->FreeAllocationUnits);
5047 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
5048 (unsigned long long)FSData->f_blocks,
5049 (unsigned long long)FSData->f_bfree,
5050 FSData->f_bsize);
5051 }
5052 }
5053 cifs_buf_release(pSMB);
5054
5055 if (rc == -EAGAIN)
5056 goto oldQFSInfoRetry;
5057
5058 return rc;
5059 }
5060
5061 int
5062 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
5063 struct kstatfs *FSData)
5064 {
5065 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5066 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5067 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5068 FILE_SYSTEM_INFO *response_data;
5069 int rc = 0;
5070 int bytes_returned = 0;
5071 __u16 params, byte_count;
5072
5073 cifs_dbg(FYI, "In QFSInfo\n");
5074 QFSInfoRetry:
5075 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5076 (void **) &pSMBr);
5077 if (rc)
5078 return rc;
5079
5080 params = 2; /* level */
5081 pSMB->TotalDataCount = 0;
5082 pSMB->MaxParameterCount = cpu_to_le16(2);
5083 pSMB->MaxDataCount = cpu_to_le16(1000);
5084 pSMB->MaxSetupCount = 0;
5085 pSMB->Reserved = 0;
5086 pSMB->Flags = 0;
5087 pSMB->Timeout = 0;
5088 pSMB->Reserved2 = 0;
5089 byte_count = params + 1 /* pad */ ;
5090 pSMB->TotalParameterCount = cpu_to_le16(params);
5091 pSMB->ParameterCount = pSMB->TotalParameterCount;
5092 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5093 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5094 pSMB->DataCount = 0;
5095 pSMB->DataOffset = 0;
5096 pSMB->SetupCount = 1;
5097 pSMB->Reserved3 = 0;
5098 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5099 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
5100 inc_rfc1001_len(pSMB, byte_count);
5101 pSMB->ByteCount = cpu_to_le16(byte_count);
5102
5103 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5104 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5105 if (rc) {
5106 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
5107 } else { /* decode response */
5108 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5109
5110 if (rc || get_bcc(&pSMBr->hdr) < 24)
5111 rc = -EIO; /* bad smb */
5112 else {
5113 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5114
5115 response_data =
5116 (FILE_SYSTEM_INFO
5117 *) (((char *) &pSMBr->hdr.Protocol) +
5118 data_offset);
5119 FSData->f_bsize =
5120 le32_to_cpu(response_data->BytesPerSector) *
5121 le32_to_cpu(response_data->
5122 SectorsPerAllocationUnit);
5123 FSData->f_blocks =
5124 le64_to_cpu(response_data->TotalAllocationUnits);
5125 FSData->f_bfree = FSData->f_bavail =
5126 le64_to_cpu(response_data->FreeAllocationUnits);
5127 cifs_dbg(FYI, "Blocks: %lld Free: %lld Block size %ld\n",
5128 (unsigned long long)FSData->f_blocks,
5129 (unsigned long long)FSData->f_bfree,
5130 FSData->f_bsize);
5131 }
5132 }
5133 cifs_buf_release(pSMB);
5134
5135 if (rc == -EAGAIN)
5136 goto QFSInfoRetry;
5137
5138 return rc;
5139 }
5140
5141 int
5142 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
5143 {
5144 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
5145 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5146 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5147 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5148 int rc = 0;
5149 int bytes_returned = 0;
5150 __u16 params, byte_count;
5151
5152 cifs_dbg(FYI, "In QFSAttributeInfo\n");
5153 QFSAttributeRetry:
5154 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5155 (void **) &pSMBr);
5156 if (rc)
5157 return rc;
5158
5159 params = 2; /* level */
5160 pSMB->TotalDataCount = 0;
5161 pSMB->MaxParameterCount = cpu_to_le16(2);
5162 /* BB find exact max SMB PDU from sess structure BB */
5163 pSMB->MaxDataCount = cpu_to_le16(1000);
5164 pSMB->MaxSetupCount = 0;
5165 pSMB->Reserved = 0;
5166 pSMB->Flags = 0;
5167 pSMB->Timeout = 0;
5168 pSMB->Reserved2 = 0;
5169 byte_count = params + 1 /* pad */ ;
5170 pSMB->TotalParameterCount = cpu_to_le16(params);
5171 pSMB->ParameterCount = pSMB->TotalParameterCount;
5172 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5173 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5174 pSMB->DataCount = 0;
5175 pSMB->DataOffset = 0;
5176 pSMB->SetupCount = 1;
5177 pSMB->Reserved3 = 0;
5178 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5179 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
5180 inc_rfc1001_len(pSMB, byte_count);
5181 pSMB->ByteCount = cpu_to_le16(byte_count);
5182
5183 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5184 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5185 if (rc) {
5186 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
5187 } else { /* decode response */
5188 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5189
5190 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5191 /* BB also check if enough bytes returned */
5192 rc = -EIO; /* bad smb */
5193 } else {
5194 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5195 response_data =
5196 (FILE_SYSTEM_ATTRIBUTE_INFO
5197 *) (((char *) &pSMBr->hdr.Protocol) +
5198 data_offset);
5199 memcpy(&tcon->fsAttrInfo, response_data,
5200 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
5201 }
5202 }
5203 cifs_buf_release(pSMB);
5204
5205 if (rc == -EAGAIN)
5206 goto QFSAttributeRetry;
5207
5208 return rc;
5209 }
5210
5211 int
5212 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
5213 {
5214 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5215 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5216 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5217 FILE_SYSTEM_DEVICE_INFO *response_data;
5218 int rc = 0;
5219 int bytes_returned = 0;
5220 __u16 params, byte_count;
5221
5222 cifs_dbg(FYI, "In QFSDeviceInfo\n");
5223 QFSDeviceRetry:
5224 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5225 (void **) &pSMBr);
5226 if (rc)
5227 return rc;
5228
5229 params = 2; /* level */
5230 pSMB->TotalDataCount = 0;
5231 pSMB->MaxParameterCount = cpu_to_le16(2);
5232 /* BB find exact max SMB PDU from sess structure BB */
5233 pSMB->MaxDataCount = cpu_to_le16(1000);
5234 pSMB->MaxSetupCount = 0;
5235 pSMB->Reserved = 0;
5236 pSMB->Flags = 0;
5237 pSMB->Timeout = 0;
5238 pSMB->Reserved2 = 0;
5239 byte_count = params + 1 /* pad */ ;
5240 pSMB->TotalParameterCount = cpu_to_le16(params);
5241 pSMB->ParameterCount = pSMB->TotalParameterCount;
5242 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5243 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5244
5245 pSMB->DataCount = 0;
5246 pSMB->DataOffset = 0;
5247 pSMB->SetupCount = 1;
5248 pSMB->Reserved3 = 0;
5249 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5250 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
5251 inc_rfc1001_len(pSMB, byte_count);
5252 pSMB->ByteCount = cpu_to_le16(byte_count);
5253
5254 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5255 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5256 if (rc) {
5257 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
5258 } else { /* decode response */
5259 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5260
5261 if (rc || get_bcc(&pSMBr->hdr) <
5262 sizeof(FILE_SYSTEM_DEVICE_INFO))
5263 rc = -EIO; /* bad smb */
5264 else {
5265 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5266 response_data =
5267 (FILE_SYSTEM_DEVICE_INFO *)
5268 (((char *) &pSMBr->hdr.Protocol) +
5269 data_offset);
5270 memcpy(&tcon->fsDevInfo, response_data,
5271 sizeof(FILE_SYSTEM_DEVICE_INFO));
5272 }
5273 }
5274 cifs_buf_release(pSMB);
5275
5276 if (rc == -EAGAIN)
5277 goto QFSDeviceRetry;
5278
5279 return rc;
5280 }
5281
5282 int
5283 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
5284 {
5285 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
5286 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5287 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5288 FILE_SYSTEM_UNIX_INFO *response_data;
5289 int rc = 0;
5290 int bytes_returned = 0;
5291 __u16 params, byte_count;
5292
5293 cifs_dbg(FYI, "In QFSUnixInfo\n");
5294 QFSUnixRetry:
5295 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5296 (void **) &pSMB, (void **) &pSMBr);
5297 if (rc)
5298 return rc;
5299
5300 params = 2; /* level */
5301 pSMB->TotalDataCount = 0;
5302 pSMB->DataCount = 0;
5303 pSMB->DataOffset = 0;
5304 pSMB->MaxParameterCount = cpu_to_le16(2);
5305 /* BB find exact max SMB PDU from sess structure BB */
5306 pSMB->MaxDataCount = cpu_to_le16(100);
5307 pSMB->MaxSetupCount = 0;
5308 pSMB->Reserved = 0;
5309 pSMB->Flags = 0;
5310 pSMB->Timeout = 0;
5311 pSMB->Reserved2 = 0;
5312 byte_count = params + 1 /* pad */ ;
5313 pSMB->ParameterCount = cpu_to_le16(params);
5314 pSMB->TotalParameterCount = pSMB->ParameterCount;
5315 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5316 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5317 pSMB->SetupCount = 1;
5318 pSMB->Reserved3 = 0;
5319 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5320 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
5321 inc_rfc1001_len(pSMB, byte_count);
5322 pSMB->ByteCount = cpu_to_le16(byte_count);
5323
5324 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5325 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5326 if (rc) {
5327 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
5328 } else { /* decode response */
5329 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5330
5331 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5332 rc = -EIO; /* bad smb */
5333 } else {
5334 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5335 response_data =
5336 (FILE_SYSTEM_UNIX_INFO
5337 *) (((char *) &pSMBr->hdr.Protocol) +
5338 data_offset);
5339 memcpy(&tcon->fsUnixInfo, response_data,
5340 sizeof(FILE_SYSTEM_UNIX_INFO));
5341 }
5342 }
5343 cifs_buf_release(pSMB);
5344
5345 if (rc == -EAGAIN)
5346 goto QFSUnixRetry;
5347
5348
5349 return rc;
5350 }
5351
5352 int
5353 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
5354 {
5355 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
5356 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5357 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5358 int rc = 0;
5359 int bytes_returned = 0;
5360 __u16 params, param_offset, offset, byte_count;
5361
5362 cifs_dbg(FYI, "In SETFSUnixInfo\n");
5363 SETFSUnixRetry:
5364 /* BB switch to small buf init to save memory */
5365 rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5366 (void **) &pSMB, (void **) &pSMBr);
5367 if (rc)
5368 return rc;
5369
5370 params = 4; /* 2 bytes zero followed by info level. */
5371 pSMB->MaxSetupCount = 0;
5372 pSMB->Reserved = 0;
5373 pSMB->Flags = 0;
5374 pSMB->Timeout = 0;
5375 pSMB->Reserved2 = 0;
5376 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5377 - 4;
5378 offset = param_offset + params;
5379
5380 pSMB->MaxParameterCount = cpu_to_le16(4);
5381 /* BB find exact max SMB PDU from sess structure BB */
5382 pSMB->MaxDataCount = cpu_to_le16(100);
5383 pSMB->SetupCount = 1;
5384 pSMB->Reserved3 = 0;
5385 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5386 byte_count = 1 /* pad */ + params + 12;
5387
5388 pSMB->DataCount = cpu_to_le16(12);
5389 pSMB->ParameterCount = cpu_to_le16(params);
5390 pSMB->TotalDataCount = pSMB->DataCount;
5391 pSMB->TotalParameterCount = pSMB->ParameterCount;
5392 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5393 pSMB->DataOffset = cpu_to_le16(offset);
5394
5395 /* Params. */
5396 pSMB->FileNum = 0;
5397 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5398
5399 /* Data. */
5400 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5401 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5402 pSMB->ClientUnixCap = cpu_to_le64(cap);
5403
5404 inc_rfc1001_len(pSMB, byte_count);
5405 pSMB->ByteCount = cpu_to_le16(byte_count);
5406
5407 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5408 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5409 if (rc) {
5410 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
5411 } else { /* decode response */
5412 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5413 if (rc)
5414 rc = -EIO; /* bad smb */
5415 }
5416 cifs_buf_release(pSMB);
5417
5418 if (rc == -EAGAIN)
5419 goto SETFSUnixRetry;
5420
5421 return rc;
5422 }
5423
5424
5425
5426 int
5427 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
5428 struct kstatfs *FSData)
5429 {
5430 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
5431 TRANSACTION2_QFSI_REQ *pSMB = NULL;
5432 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5433 FILE_SYSTEM_POSIX_INFO *response_data;
5434 int rc = 0;
5435 int bytes_returned = 0;
5436 __u16 params, byte_count;
5437
5438 cifs_dbg(FYI, "In QFSPosixInfo\n");
5439 QFSPosixRetry:
5440 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5441 (void **) &pSMBr);
5442 if (rc)
5443 return rc;
5444
5445 params = 2; /* level */
5446 pSMB->TotalDataCount = 0;
5447 pSMB->DataCount = 0;
5448 pSMB->DataOffset = 0;
5449 pSMB->MaxParameterCount = cpu_to_le16(2);
5450 /* BB find exact max SMB PDU from sess structure BB */
5451 pSMB->MaxDataCount = cpu_to_le16(100);
5452 pSMB->MaxSetupCount = 0;
5453 pSMB->Reserved = 0;
5454 pSMB->Flags = 0;
5455 pSMB->Timeout = 0;
5456 pSMB->Reserved2 = 0;
5457 byte_count = params + 1 /* pad */ ;
5458 pSMB->ParameterCount = cpu_to_le16(params);
5459 pSMB->TotalParameterCount = pSMB->ParameterCount;
5460 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5461 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5462 pSMB->SetupCount = 1;
5463 pSMB->Reserved3 = 0;
5464 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5465 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
5466 inc_rfc1001_len(pSMB, byte_count);
5467 pSMB->ByteCount = cpu_to_le16(byte_count);
5468
5469 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5470 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5471 if (rc) {
5472 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
5473 } else { /* decode response */
5474 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5475
5476 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5477 rc = -EIO; /* bad smb */
5478 } else {
5479 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5480 response_data =
5481 (FILE_SYSTEM_POSIX_INFO
5482 *) (((char *) &pSMBr->hdr.Protocol) +
5483 data_offset);
5484 FSData->f_bsize =
5485 le32_to_cpu(response_data->BlockSize);
5486 FSData->f_blocks =
5487 le64_to_cpu(response_data->TotalBlocks);
5488 FSData->f_bfree =
5489 le64_to_cpu(response_data->BlocksAvail);
5490 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
5491 FSData->f_bavail = FSData->f_bfree;
5492 } else {
5493 FSData->f_bavail =
5494 le64_to_cpu(response_data->UserBlocksAvail);
5495 }
5496 if (response_data->TotalFileNodes != cpu_to_le64(-1))
5497 FSData->f_files =
5498 le64_to_cpu(response_data->TotalFileNodes);
5499 if (response_data->FreeFileNodes != cpu_to_le64(-1))
5500 FSData->f_ffree =
5501 le64_to_cpu(response_data->FreeFileNodes);
5502 }
5503 }
5504 cifs_buf_release(pSMB);
5505
5506 if (rc == -EAGAIN)
5507 goto QFSPosixRetry;
5508
5509 return rc;
5510 }
5511
5512
5513 /*
5514 * We can not use write of zero bytes trick to set file size due to need for
5515 * large file support. Also note that this SetPathInfo is preferred to
5516 * SetFileInfo based method in next routine which is only needed to work around
5517 * a sharing violation bugin Samba which this routine can run into.
5518 */
5519 int
5520 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
5521 const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
5522 bool set_allocation)
5523 {
5524 struct smb_com_transaction2_spi_req *pSMB = NULL;
5525 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5526 struct file_end_of_file_info *parm_data;
5527 int name_len;
5528 int rc = 0;
5529 int bytes_returned = 0;
5530 int remap = cifs_remap(cifs_sb);
5531
5532 __u16 params, byte_count, data_count, param_offset, offset;
5533
5534 cifs_dbg(FYI, "In SetEOF\n");
5535 SetEOFRetry:
5536 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5537 (void **) &pSMBr);
5538 if (rc)
5539 return rc;
5540
5541 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5542 name_len =
5543 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5544 PATH_MAX, cifs_sb->local_nls, remap);
5545 name_len++; /* trailing null */
5546 name_len *= 2;
5547 } else { /* BB improve the check for buffer overruns BB */
5548 name_len = strnlen(file_name, PATH_MAX);
5549 name_len++; /* trailing null */
5550 strncpy(pSMB->FileName, file_name, name_len);
5551 }
5552 params = 6 + name_len;
5553 data_count = sizeof(struct file_end_of_file_info);
5554 pSMB->MaxParameterCount = cpu_to_le16(2);
5555 pSMB->MaxDataCount = cpu_to_le16(4100);
5556 pSMB->MaxSetupCount = 0;
5557 pSMB->Reserved = 0;
5558 pSMB->Flags = 0;
5559 pSMB->Timeout = 0;
5560 pSMB->Reserved2 = 0;
5561 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5562 InformationLevel) - 4;
5563 offset = param_offset + params;
5564 if (set_allocation) {
5565 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5566 pSMB->InformationLevel =
5567 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5568 else
5569 pSMB->InformationLevel =
5570 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5571 } else /* Set File Size */ {
5572 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5573 pSMB->InformationLevel =
5574 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5575 else
5576 pSMB->InformationLevel =
5577 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5578 }
5579
5580 parm_data =
5581 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5582 offset);
5583 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5584 pSMB->DataOffset = cpu_to_le16(offset);
5585 pSMB->SetupCount = 1;
5586 pSMB->Reserved3 = 0;
5587 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5588 byte_count = 3 /* pad */ + params + data_count;
5589 pSMB->DataCount = cpu_to_le16(data_count);
5590 pSMB->TotalDataCount = pSMB->DataCount;
5591 pSMB->ParameterCount = cpu_to_le16(params);
5592 pSMB->TotalParameterCount = pSMB->ParameterCount;
5593 pSMB->Reserved4 = 0;
5594 inc_rfc1001_len(pSMB, byte_count);
5595 parm_data->FileSize = cpu_to_le64(size);
5596 pSMB->ByteCount = cpu_to_le16(byte_count);
5597 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5598 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5599 if (rc)
5600 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
5601
5602 cifs_buf_release(pSMB);
5603
5604 if (rc == -EAGAIN)
5605 goto SetEOFRetry;
5606
5607 return rc;
5608 }
5609
5610 int
5611 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5612 struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
5613 {
5614 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5615 struct file_end_of_file_info *parm_data;
5616 int rc = 0;
5617 __u16 params, param_offset, offset, byte_count, count;
5618
5619 cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5620 (long long)size);
5621 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5622
5623 if (rc)
5624 return rc;
5625
5626 pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5627 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
5628
5629 params = 6;
5630 pSMB->MaxSetupCount = 0;
5631 pSMB->Reserved = 0;
5632 pSMB->Flags = 0;
5633 pSMB->Timeout = 0;
5634 pSMB->Reserved2 = 0;
5635 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5636 offset = param_offset + params;
5637
5638 count = sizeof(struct file_end_of_file_info);
5639 pSMB->MaxParameterCount = cpu_to_le16(2);
5640 /* BB find exact max SMB PDU from sess structure BB */
5641 pSMB->MaxDataCount = cpu_to_le16(1000);
5642 pSMB->SetupCount = 1;
5643 pSMB->Reserved3 = 0;
5644 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5645 byte_count = 3 /* pad */ + params + count;
5646 pSMB->DataCount = cpu_to_le16(count);
5647 pSMB->ParameterCount = cpu_to_le16(params);
5648 pSMB->TotalDataCount = pSMB->DataCount;
5649 pSMB->TotalParameterCount = pSMB->ParameterCount;
5650 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5651 parm_data =
5652 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5653 + offset);
5654 pSMB->DataOffset = cpu_to_le16(offset);
5655 parm_data->FileSize = cpu_to_le64(size);
5656 pSMB->Fid = cfile->fid.netfid;
5657 if (set_allocation) {
5658 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5659 pSMB->InformationLevel =
5660 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5661 else
5662 pSMB->InformationLevel =
5663 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5664 } else /* Set File Size */ {
5665 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5666 pSMB->InformationLevel =
5667 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5668 else
5669 pSMB->InformationLevel =
5670 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5671 }
5672 pSMB->Reserved4 = 0;
5673 inc_rfc1001_len(pSMB, byte_count);
5674 pSMB->ByteCount = cpu_to_le16(byte_count);
5675 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5676 if (rc) {
5677 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5678 rc);
5679 }
5680
5681 /* Note: On -EAGAIN error only caller can retry on handle based calls
5682 since file handle passed in no longer valid */
5683
5684 return rc;
5685 }
5686
5687 /* Some legacy servers such as NT4 require that the file times be set on
5688 an open handle, rather than by pathname - this is awkward due to
5689 potential access conflicts on the open, but it is unavoidable for these
5690 old servers since the only other choice is to go from 100 nanosecond DCE
5691 time and resort to the original setpathinfo level which takes the ancient
5692 DOS time format with 2 second granularity */
5693 int
5694 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5695 const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5696 {
5697 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5698 char *data_offset;
5699 int rc = 0;
5700 __u16 params, param_offset, offset, byte_count, count;
5701
5702 cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
5703 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5704
5705 if (rc)
5706 return rc;
5707
5708 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5709 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5710
5711 params = 6;
5712 pSMB->MaxSetupCount = 0;
5713 pSMB->Reserved = 0;
5714 pSMB->Flags = 0;
5715 pSMB->Timeout = 0;
5716 pSMB->Reserved2 = 0;
5717 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5718 offset = param_offset + params;
5719
5720 data_offset = (char *)pSMB +
5721 offsetof(struct smb_hdr, Protocol) + offset;
5722
5723 count = sizeof(FILE_BASIC_INFO);
5724 pSMB->MaxParameterCount = cpu_to_le16(2);
5725 /* BB find max SMB PDU from sess */
5726 pSMB->MaxDataCount = cpu_to_le16(1000);
5727 pSMB->SetupCount = 1;
5728 pSMB->Reserved3 = 0;
5729 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5730 byte_count = 3 /* pad */ + params + count;
5731 pSMB->DataCount = cpu_to_le16(count);
5732 pSMB->ParameterCount = cpu_to_le16(params);
5733 pSMB->TotalDataCount = pSMB->DataCount;
5734 pSMB->TotalParameterCount = pSMB->ParameterCount;
5735 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5736 pSMB->DataOffset = cpu_to_le16(offset);
5737 pSMB->Fid = fid;
5738 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5739 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5740 else
5741 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5742 pSMB->Reserved4 = 0;
5743 inc_rfc1001_len(pSMB, byte_count);
5744 pSMB->ByteCount = cpu_to_le16(byte_count);
5745 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5746 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5747 if (rc)
5748 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5749 rc);
5750
5751 /* Note: On -EAGAIN error only caller can retry on handle based calls
5752 since file handle passed in no longer valid */
5753
5754 return rc;
5755 }
5756
5757 int
5758 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
5759 bool delete_file, __u16 fid, __u32 pid_of_opener)
5760 {
5761 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5762 char *data_offset;
5763 int rc = 0;
5764 __u16 params, param_offset, offset, byte_count, count;
5765
5766 cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
5767 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5768
5769 if (rc)
5770 return rc;
5771
5772 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5773 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5774
5775 params = 6;
5776 pSMB->MaxSetupCount = 0;
5777 pSMB->Reserved = 0;
5778 pSMB->Flags = 0;
5779 pSMB->Timeout = 0;
5780 pSMB->Reserved2 = 0;
5781 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5782 offset = param_offset + params;
5783
5784 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5785
5786 count = 1;
5787 pSMB->MaxParameterCount = cpu_to_le16(2);
5788 /* BB find max SMB PDU from sess */
5789 pSMB->MaxDataCount = cpu_to_le16(1000);
5790 pSMB->SetupCount = 1;
5791 pSMB->Reserved3 = 0;
5792 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5793 byte_count = 3 /* pad */ + params + count;
5794 pSMB->DataCount = cpu_to_le16(count);
5795 pSMB->ParameterCount = cpu_to_le16(params);
5796 pSMB->TotalDataCount = pSMB->DataCount;
5797 pSMB->TotalParameterCount = pSMB->ParameterCount;
5798 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5799 pSMB->DataOffset = cpu_to_le16(offset);
5800 pSMB->Fid = fid;
5801 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5802 pSMB->Reserved4 = 0;
5803 inc_rfc1001_len(pSMB, byte_count);
5804 pSMB->ByteCount = cpu_to_le16(byte_count);
5805 *data_offset = delete_file ? 1 : 0;
5806 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5807 if (rc)
5808 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
5809
5810 return rc;
5811 }
5812
5813 int
5814 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5815 const char *fileName, const FILE_BASIC_INFO *data,
5816 const struct nls_table *nls_codepage, int remap)
5817 {
5818 TRANSACTION2_SPI_REQ *pSMB = NULL;
5819 TRANSACTION2_SPI_RSP *pSMBr = NULL;
5820 int name_len;
5821 int rc = 0;
5822 int bytes_returned = 0;
5823 char *data_offset;
5824 __u16 params, param_offset, offset, byte_count, count;
5825
5826 cifs_dbg(FYI, "In SetTimes\n");
5827
5828 SetTimesRetry:
5829 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5830 (void **) &pSMBr);
5831 if (rc)
5832 return rc;
5833
5834 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5835 name_len =
5836 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5837 PATH_MAX, nls_codepage, remap);
5838 name_len++; /* trailing null */
5839 name_len *= 2;
5840 } else { /* BB improve the check for buffer overruns BB */
5841 name_len = strnlen(fileName, PATH_MAX);
5842 name_len++; /* trailing null */
5843 strncpy(pSMB->FileName, fileName, name_len);
5844 }
5845
5846 params = 6 + name_len;
5847 count = sizeof(FILE_BASIC_INFO);
5848 pSMB->MaxParameterCount = cpu_to_le16(2);
5849 /* BB find max SMB PDU from sess structure BB */
5850 pSMB->MaxDataCount = cpu_to_le16(1000);
5851 pSMB->MaxSetupCount = 0;
5852 pSMB->Reserved = 0;
5853 pSMB->Flags = 0;
5854 pSMB->Timeout = 0;
5855 pSMB->Reserved2 = 0;
5856 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5857 InformationLevel) - 4;
5858 offset = param_offset + params;
5859 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5860 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5861 pSMB->DataOffset = cpu_to_le16(offset);
5862 pSMB->SetupCount = 1;
5863 pSMB->Reserved3 = 0;
5864 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5865 byte_count = 3 /* pad */ + params + count;
5866
5867 pSMB->DataCount = cpu_to_le16(count);
5868 pSMB->ParameterCount = cpu_to_le16(params);
5869 pSMB->TotalDataCount = pSMB->DataCount;
5870 pSMB->TotalParameterCount = pSMB->ParameterCount;
5871 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5872 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5873 else
5874 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5875 pSMB->Reserved4 = 0;
5876 inc_rfc1001_len(pSMB, byte_count);
5877 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5878 pSMB->ByteCount = cpu_to_le16(byte_count);
5879 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5880 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5881 if (rc)
5882 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
5883
5884 cifs_buf_release(pSMB);
5885
5886 if (rc == -EAGAIN)
5887 goto SetTimesRetry;
5888
5889 return rc;
5890 }
5891
5892 /* Can not be used to set time stamps yet (due to old DOS time format) */
5893 /* Can be used to set attributes */
5894 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
5895 handling it anyway and NT4 was what we thought it would be needed for
5896 Do not delete it until we prove whether needed for Win9x though */
5897 int
5898 CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon, char *fileName,
5899 __u16 dos_attrs, const struct nls_table *nls_codepage)
5900 {
5901 SETATTR_REQ *pSMB = NULL;
5902 SETATTR_RSP *pSMBr = NULL;
5903 int rc = 0;
5904 int bytes_returned;
5905 int name_len;
5906
5907 cifs_dbg(FYI, "In SetAttrLegacy\n");
5908
5909 SetAttrLgcyRetry:
5910 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5911 (void **) &pSMBr);
5912 if (rc)
5913 return rc;
5914
5915 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5916 name_len =
5917 ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5918 PATH_MAX, nls_codepage);
5919 name_len++; /* trailing null */
5920 name_len *= 2;
5921 } else { /* BB improve the check for buffer overruns BB */
5922 name_len = strnlen(fileName, PATH_MAX);
5923 name_len++; /* trailing null */
5924 strncpy(pSMB->fileName, fileName, name_len);
5925 }
5926 pSMB->attr = cpu_to_le16(dos_attrs);
5927 pSMB->BufferFormat = 0x04;
5928 inc_rfc1001_len(pSMB, name_len + 1);
5929 pSMB->ByteCount = cpu_to_le16(name_len + 1);
5930 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5931 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5932 if (rc)
5933 cifs_dbg(FYI, "Error in LegacySetAttr = %d\n", rc);
5934
5935 cifs_buf_release(pSMB);
5936
5937 if (rc == -EAGAIN)
5938 goto SetAttrLgcyRetry;
5939
5940 return rc;
5941 }
5942 #endif /* temporarily unneeded SetAttr legacy function */
5943
5944 static void
5945 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5946 const struct cifs_unix_set_info_args *args)
5947 {
5948 u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
5949 u64 mode = args->mode;
5950
5951 if (uid_valid(args->uid))
5952 uid = from_kuid(&init_user_ns, args->uid);
5953 if (gid_valid(args->gid))
5954 gid = from_kgid(&init_user_ns, args->gid);
5955
5956 /*
5957 * Samba server ignores set of file size to zero due to bugs in some
5958 * older clients, but we should be precise - we use SetFileSize to
5959 * set file size and do not want to truncate file size to zero
5960 * accidentally as happened on one Samba server beta by putting
5961 * zero instead of -1 here
5962 */
5963 data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5964 data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5965 data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5966 data_offset->LastAccessTime = cpu_to_le64(args->atime);
5967 data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5968 data_offset->Uid = cpu_to_le64(uid);
5969 data_offset->Gid = cpu_to_le64(gid);
5970 /* better to leave device as zero when it is */
5971 data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5972 data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5973 data_offset->Permissions = cpu_to_le64(mode);
5974
5975 if (S_ISREG(mode))
5976 data_offset->Type = cpu_to_le32(UNIX_FILE);
5977 else if (S_ISDIR(mode))
5978 data_offset->Type = cpu_to_le32(UNIX_DIR);
5979 else if (S_ISLNK(mode))
5980 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5981 else if (S_ISCHR(mode))
5982 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5983 else if (S_ISBLK(mode))
5984 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5985 else if (S_ISFIFO(mode))
5986 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5987 else if (S_ISSOCK(mode))
5988 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5989 }
5990
5991 int
5992 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5993 const struct cifs_unix_set_info_args *args,
5994 u16 fid, u32 pid_of_opener)
5995 {
5996 struct smb_com_transaction2_sfi_req *pSMB = NULL;
5997 char *data_offset;
5998 int rc = 0;
5999 u16 params, param_offset, offset, byte_count, count;
6000
6001 cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
6002 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
6003
6004 if (rc)
6005 return rc;
6006
6007 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
6008 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
6009
6010 params = 6;
6011 pSMB->MaxSetupCount = 0;
6012 pSMB->Reserved = 0;
6013 pSMB->Flags = 0;
6014 pSMB->Timeout = 0;
6015 pSMB->Reserved2 = 0;
6016 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
6017 offset = param_offset + params;
6018
6019 data_offset = (char *)pSMB +
6020 offsetof(struct smb_hdr, Protocol) + offset;
6021
6022 count = sizeof(FILE_UNIX_BASIC_INFO);
6023
6024 pSMB->MaxParameterCount = cpu_to_le16(2);
6025 /* BB find max SMB PDU from sess */
6026 pSMB->MaxDataCount = cpu_to_le16(1000);
6027 pSMB->SetupCount = 1;
6028 pSMB->Reserved3 = 0;
6029 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
6030 byte_count = 3 /* pad */ + params + count;
6031 pSMB->DataCount = cpu_to_le16(count);
6032 pSMB->ParameterCount = cpu_to_le16(params);
6033 pSMB->TotalDataCount = pSMB->DataCount;
6034 pSMB->TotalParameterCount = pSMB->ParameterCount;
6035 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6036 pSMB->DataOffset = cpu_to_le16(offset);
6037 pSMB->Fid = fid;
6038 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6039 pSMB->Reserved4 = 0;
6040 inc_rfc1001_len(pSMB, byte_count);
6041 pSMB->ByteCount = cpu_to_le16(byte_count);
6042
6043 cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
6044
6045 rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
6046 if (rc)
6047 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
6048 rc);
6049
6050 /* Note: On -EAGAIN error only caller can retry on handle based calls
6051 since file handle passed in no longer valid */
6052
6053 return rc;
6054 }
6055
6056 int
6057 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
6058 const char *file_name,
6059 const struct cifs_unix_set_info_args *args,
6060 const struct nls_table *nls_codepage, int remap)
6061 {
6062 TRANSACTION2_SPI_REQ *pSMB = NULL;
6063 TRANSACTION2_SPI_RSP *pSMBr = NULL;
6064 int name_len;
6065 int rc = 0;
6066 int bytes_returned = 0;
6067 FILE_UNIX_BASIC_INFO *data_offset;
6068 __u16 params, param_offset, offset, count, byte_count;
6069
6070 cifs_dbg(FYI, "In SetUID/GID/Mode\n");
6071 setPermsRetry:
6072 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6073 (void **) &pSMBr);
6074 if (rc)
6075 return rc;
6076
6077 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6078 name_len =
6079 cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
6080 PATH_MAX, nls_codepage, remap);
6081 name_len++; /* trailing null */
6082 name_len *= 2;
6083 } else { /* BB improve the check for buffer overruns BB */
6084 name_len = strnlen(file_name, PATH_MAX);
6085 name_len++; /* trailing null */
6086 strncpy(pSMB->FileName, file_name, name_len);
6087 }
6088
6089 params = 6 + name_len;
6090 count = sizeof(FILE_UNIX_BASIC_INFO);
6091 pSMB->MaxParameterCount = cpu_to_le16(2);
6092 /* BB find max SMB PDU from sess structure BB */
6093 pSMB->MaxDataCount = cpu_to_le16(1000);
6094 pSMB->MaxSetupCount = 0;
6095 pSMB->Reserved = 0;
6096 pSMB->Flags = 0;
6097 pSMB->Timeout = 0;
6098 pSMB->Reserved2 = 0;
6099 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6100 InformationLevel) - 4;
6101 offset = param_offset + params;
6102 data_offset =
6103 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6104 offset);
6105 memset(data_offset, 0, count);
6106 pSMB->DataOffset = cpu_to_le16(offset);
6107 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6108 pSMB->SetupCount = 1;
6109 pSMB->Reserved3 = 0;
6110 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6111 byte_count = 3 /* pad */ + params + count;
6112 pSMB->ParameterCount = cpu_to_le16(params);
6113 pSMB->DataCount = cpu_to_le16(count);
6114 pSMB->TotalParameterCount = pSMB->ParameterCount;
6115 pSMB->TotalDataCount = pSMB->DataCount;
6116 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6117 pSMB->Reserved4 = 0;
6118 inc_rfc1001_len(pSMB, byte_count);
6119
6120 cifs_fill_unix_set_info(data_offset, args);
6121
6122 pSMB->ByteCount = cpu_to_le16(byte_count);
6123 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6124 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6125 if (rc)
6126 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
6127
6128 cifs_buf_release(pSMB);
6129 if (rc == -EAGAIN)
6130 goto setPermsRetry;
6131 return rc;
6132 }
6133
6134 #ifdef CONFIG_CIFS_XATTR
6135 /*
6136 * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6137 * function used by listxattr and getxattr type calls. When ea_name is set,
6138 * it looks for that attribute name and stuffs that value into the EAData
6139 * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6140 * buffer. In both cases, the return value is either the length of the
6141 * resulting data or a negative error code. If EAData is a NULL pointer then
6142 * the data isn't copied to it, but the length is returned.
6143 */
6144 ssize_t
6145 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
6146 const unsigned char *searchName, const unsigned char *ea_name,
6147 char *EAData, size_t buf_size,
6148 const struct nls_table *nls_codepage, int remap)
6149 {
6150 /* BB assumes one setup word */
6151 TRANSACTION2_QPI_REQ *pSMB = NULL;
6152 TRANSACTION2_QPI_RSP *pSMBr = NULL;
6153 int rc = 0;
6154 int bytes_returned;
6155 int list_len;
6156 struct fealist *ea_response_data;
6157 struct fea *temp_fea;
6158 char *temp_ptr;
6159 char *end_of_smb;
6160 __u16 params, byte_count, data_offset;
6161 unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
6162
6163 cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
6164 QAllEAsRetry:
6165 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6166 (void **) &pSMBr);
6167 if (rc)
6168 return rc;
6169
6170 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6171 list_len =
6172 cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6173 PATH_MAX, nls_codepage, remap);
6174 list_len++; /* trailing null */
6175 list_len *= 2;
6176 } else { /* BB improve the check for buffer overruns BB */
6177 list_len = strnlen(searchName, PATH_MAX);
6178 list_len++; /* trailing null */
6179 strncpy(pSMB->FileName, searchName, list_len);
6180 }
6181
6182 params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
6183 pSMB->TotalDataCount = 0;
6184 pSMB->MaxParameterCount = cpu_to_le16(2);
6185 /* BB find exact max SMB PDU from sess structure BB */
6186 pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
6187 pSMB->MaxSetupCount = 0;
6188 pSMB->Reserved = 0;
6189 pSMB->Flags = 0;
6190 pSMB->Timeout = 0;
6191 pSMB->Reserved2 = 0;
6192 pSMB->ParameterOffset = cpu_to_le16(offsetof(
6193 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
6194 pSMB->DataCount = 0;
6195 pSMB->DataOffset = 0;
6196 pSMB->SetupCount = 1;
6197 pSMB->Reserved3 = 0;
6198 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6199 byte_count = params + 1 /* pad */ ;
6200 pSMB->TotalParameterCount = cpu_to_le16(params);
6201 pSMB->ParameterCount = pSMB->TotalParameterCount;
6202 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6203 pSMB->Reserved4 = 0;
6204 inc_rfc1001_len(pSMB, byte_count);
6205 pSMB->ByteCount = cpu_to_le16(byte_count);
6206
6207 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6208 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6209 if (rc) {
6210 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
6211 goto QAllEAsOut;
6212 }
6213
6214
6215 /* BB also check enough total bytes returned */
6216 /* BB we need to improve the validity checking
6217 of these trans2 responses */
6218
6219 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6220 if (rc || get_bcc(&pSMBr->hdr) < 4) {
6221 rc = -EIO; /* bad smb */
6222 goto QAllEAsOut;
6223 }
6224
6225 /* check that length of list is not more than bcc */
6226 /* check that each entry does not go beyond length
6227 of list */
6228 /* check that each element of each entry does not
6229 go beyond end of list */
6230 /* validate_trans2_offsets() */
6231 /* BB check if start of smb + data_offset > &bcc+ bcc */
6232
6233 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6234 ea_response_data = (struct fealist *)
6235 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6236
6237 list_len = le32_to_cpu(ea_response_data->list_len);
6238 cifs_dbg(FYI, "ea length %d\n", list_len);
6239 if (list_len <= 8) {
6240 cifs_dbg(FYI, "empty EA list returned from server\n");
6241 /* didn't find the named attribute */
6242 if (ea_name)
6243 rc = -ENODATA;
6244 goto QAllEAsOut;
6245 }
6246
6247 /* make sure list_len doesn't go past end of SMB */
6248 end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
6249 if ((char *)ea_response_data + list_len > end_of_smb) {
6250 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
6251 rc = -EIO;
6252 goto QAllEAsOut;
6253 }
6254
6255 /* account for ea list len */
6256 list_len -= 4;
6257 temp_fea = ea_response_data->list;
6258 temp_ptr = (char *)temp_fea;
6259 while (list_len > 0) {
6260 unsigned int name_len;
6261 __u16 value_len;
6262
6263 list_len -= 4;
6264 temp_ptr += 4;
6265 /* make sure we can read name_len and value_len */
6266 if (list_len < 0) {
6267 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6268 rc = -EIO;
6269 goto QAllEAsOut;
6270 }
6271
6272 name_len = temp_fea->name_len;
6273 value_len = le16_to_cpu(temp_fea->value_len);
6274 list_len -= name_len + 1 + value_len;
6275 if (list_len < 0) {
6276 cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6277 rc = -EIO;
6278 goto QAllEAsOut;
6279 }
6280
6281 if (ea_name) {
6282 if (ea_name_len == name_len &&
6283 memcmp(ea_name, temp_ptr, name_len) == 0) {
6284 temp_ptr += name_len + 1;
6285 rc = value_len;
6286 if (buf_size == 0)
6287 goto QAllEAsOut;
6288 if ((size_t)value_len > buf_size) {
6289 rc = -ERANGE;
6290 goto QAllEAsOut;
6291 }
6292 memcpy(EAData, temp_ptr, value_len);
6293 goto QAllEAsOut;
6294 }
6295 } else {
6296 /* account for prefix user. and trailing null */
6297 rc += (5 + 1 + name_len);
6298 if (rc < (int) buf_size) {
6299 memcpy(EAData, "user.", 5);
6300 EAData += 5;
6301 memcpy(EAData, temp_ptr, name_len);
6302 EAData += name_len;
6303 /* null terminate name */
6304 *EAData = 0;
6305 ++EAData;
6306 } else if (buf_size == 0) {
6307 /* skip copy - calc size only */
6308 } else {
6309 /* stop before overrun buffer */
6310 rc = -ERANGE;
6311 break;
6312 }
6313 }
6314 temp_ptr += name_len + 1 + value_len;
6315 temp_fea = (struct fea *)temp_ptr;
6316 }
6317
6318 /* didn't find the named attribute */
6319 if (ea_name)
6320 rc = -ENODATA;
6321
6322 QAllEAsOut:
6323 cifs_buf_release(pSMB);
6324 if (rc == -EAGAIN)
6325 goto QAllEAsRetry;
6326
6327 return (ssize_t)rc;
6328 }
6329
6330 int
6331 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
6332 const char *fileName, const char *ea_name, const void *ea_value,
6333 const __u16 ea_value_len, const struct nls_table *nls_codepage,
6334 int remap)
6335 {
6336 struct smb_com_transaction2_spi_req *pSMB = NULL;
6337 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6338 struct fealist *parm_data;
6339 int name_len;
6340 int rc = 0;
6341 int bytes_returned = 0;
6342 __u16 params, param_offset, byte_count, offset, count;
6343
6344 cifs_dbg(FYI, "In SetEA\n");
6345 SetEARetry:
6346 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6347 (void **) &pSMBr);
6348 if (rc)
6349 return rc;
6350
6351 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6352 name_len =
6353 cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6354 PATH_MAX, nls_codepage, remap);
6355 name_len++; /* trailing null */
6356 name_len *= 2;
6357 } else { /* BB improve the check for buffer overruns BB */
6358 name_len = strnlen(fileName, PATH_MAX);
6359 name_len++; /* trailing null */
6360 strncpy(pSMB->FileName, fileName, name_len);
6361 }
6362
6363 params = 6 + name_len;
6364
6365 /* done calculating parms using name_len of file name,
6366 now use name_len to calculate length of ea name
6367 we are going to create in the inode xattrs */
6368 if (ea_name == NULL)
6369 name_len = 0;
6370 else
6371 name_len = strnlen(ea_name, 255);
6372
6373 count = sizeof(*parm_data) + ea_value_len + name_len;
6374 pSMB->MaxParameterCount = cpu_to_le16(2);
6375 /* BB find max SMB PDU from sess */
6376 pSMB->MaxDataCount = cpu_to_le16(1000);
6377 pSMB->MaxSetupCount = 0;
6378 pSMB->Reserved = 0;
6379 pSMB->Flags = 0;
6380 pSMB->Timeout = 0;
6381 pSMB->Reserved2 = 0;
6382 param_offset = offsetof(struct smb_com_transaction2_spi_req,
6383 InformationLevel) - 4;
6384 offset = param_offset + params;
6385 pSMB->InformationLevel =
6386 cpu_to_le16(SMB_SET_FILE_EA);
6387
6388 parm_data =
6389 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
6390 offset);
6391 pSMB->ParameterOffset = cpu_to_le16(param_offset);
6392 pSMB->DataOffset = cpu_to_le16(offset);
6393 pSMB->SetupCount = 1;
6394 pSMB->Reserved3 = 0;
6395 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6396 byte_count = 3 /* pad */ + params + count;
6397 pSMB->DataCount = cpu_to_le16(count);
6398 parm_data->list_len = cpu_to_le32(count);
6399 parm_data->list[0].EA_flags = 0;
6400 /* we checked above that name len is less than 255 */
6401 parm_data->list[0].name_len = (__u8)name_len;
6402 /* EA names are always ASCII */
6403 if (ea_name)
6404 strncpy(parm_data->list[0].name, ea_name, name_len);
6405 parm_data->list[0].name[name_len] = 0;
6406 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6407 /* caller ensures that ea_value_len is less than 64K but
6408 we need to ensure that it fits within the smb */
6409
6410 /*BB add length check to see if it would fit in
6411 negotiated SMB buffer size BB */
6412 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6413 if (ea_value_len)
6414 memcpy(parm_data->list[0].name+name_len+1,
6415 ea_value, ea_value_len);
6416
6417 pSMB->TotalDataCount = pSMB->DataCount;
6418 pSMB->ParameterCount = cpu_to_le16(params);
6419 pSMB->TotalParameterCount = pSMB->ParameterCount;
6420 pSMB->Reserved4 = 0;
6421 inc_rfc1001_len(pSMB, byte_count);
6422 pSMB->ByteCount = cpu_to_le16(byte_count);
6423 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6424 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6425 if (rc)
6426 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
6427
6428 cifs_buf_release(pSMB);
6429
6430 if (rc == -EAGAIN)
6431 goto SetEARetry;
6432
6433 return rc;
6434 }
6435 #endif
6436
6437 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6438 /*
6439 * Years ago the kernel added a "dnotify" function for Samba server,
6440 * to allow network clients (such as Windows) to display updated
6441 * lists of files in directory listings automatically when
6442 * files are added by one user when another user has the
6443 * same directory open on their desktop. The Linux cifs kernel
6444 * client hooked into the kernel side of this interface for
6445 * the same reason, but ironically when the VFS moved from
6446 * "dnotify" to "inotify" it became harder to plug in Linux
6447 * network file system clients (the most obvious use case
6448 * for notify interfaces is when multiple users can update
6449 * the contents of the same directory - exactly what network
6450 * file systems can do) although the server (Samba) could
6451 * still use it. For the short term we leave the worker
6452 * function ifdeffed out (below) until inotify is fixed
6453 * in the VFS to make it easier to plug in network file
6454 * system clients. If inotify turns out to be permanently
6455 * incompatible for network fs clients, we could instead simply
6456 * expose this config flag by adding a future cifs (and smb2) notify ioctl.
6457 */
6458 int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
6459 const int notify_subdirs, const __u16 netfid,
6460 __u32 filter, struct file *pfile, int multishot,
6461 const struct nls_table *nls_codepage)
6462 {
6463 int rc = 0;
6464 struct smb_com_transaction_change_notify_req *pSMB = NULL;
6465 struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6466 struct dir_notify_req *dnotify_req;
6467 int bytes_returned;
6468
6469 cifs_dbg(FYI, "In CIFSSMBNotify for file handle %d\n", (int)netfid);
6470 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6471 (void **) &pSMBr);
6472 if (rc)
6473 return rc;
6474
6475 pSMB->TotalParameterCount = 0 ;
6476 pSMB->TotalDataCount = 0;
6477 pSMB->MaxParameterCount = cpu_to_le32(2);
6478 pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
6479 pSMB->MaxSetupCount = 4;
6480 pSMB->Reserved = 0;
6481 pSMB->ParameterOffset = 0;
6482 pSMB->DataCount = 0;
6483 pSMB->DataOffset = 0;
6484 pSMB->SetupCount = 4; /* single byte does not need le conversion */
6485 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6486 pSMB->ParameterCount = pSMB->TotalParameterCount;
6487 if (notify_subdirs)
6488 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6489 pSMB->Reserved2 = 0;
6490 pSMB->CompletionFilter = cpu_to_le32(filter);
6491 pSMB->Fid = netfid; /* file handle always le */
6492 pSMB->ByteCount = 0;
6493
6494 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6495 (struct smb_hdr *)pSMBr, &bytes_returned,
6496 CIFS_ASYNC_OP);
6497 if (rc) {
6498 cifs_dbg(FYI, "Error in Notify = %d\n", rc);
6499 } else {
6500 /* Add file to outstanding requests */
6501 /* BB change to kmem cache alloc */
6502 dnotify_req = kmalloc(
6503 sizeof(struct dir_notify_req),
6504 GFP_KERNEL);
6505 if (dnotify_req) {
6506 dnotify_req->Pid = pSMB->hdr.Pid;
6507 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6508 dnotify_req->Mid = pSMB->hdr.Mid;
6509 dnotify_req->Tid = pSMB->hdr.Tid;
6510 dnotify_req->Uid = pSMB->hdr.Uid;
6511 dnotify_req->netfid = netfid;
6512 dnotify_req->pfile = pfile;
6513 dnotify_req->filter = filter;
6514 dnotify_req->multishot = multishot;
6515 spin_lock(&GlobalMid_Lock);
6516 list_add_tail(&dnotify_req->lhead,
6517 &GlobalDnotifyReqList);
6518 spin_unlock(&GlobalMid_Lock);
6519 } else
6520 rc = -ENOMEM;
6521 }
6522 cifs_buf_release(pSMB);
6523 return rc;
6524 }
6525 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
Linux kernel - Deliverables
This page took 0.178779 seconds and 5 git commands to generate.