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