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