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