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