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