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