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