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