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