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