?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
exportfs: remove old methods
[wrt350n-kernel.git] / fs / cifs / cifssmb.c
blobf0d9a485d0951f29c3f140ebda33391d7471a53d
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 /* BB Need to fill struct for sessetup here */
651 rc = -EOPNOTSUPP;
652 } else {
653 rc = -EINVAL;
654 }
655 }
656 } else
657 server->capabilities &= ~CAP_EXTENDED_SECURITY;
658
659 #ifdef CONFIG_CIFS_WEAK_PW_HASH
660 signing_check:
661 #endif
662 if ((secFlags & CIFSSEC_MAY_SIGN) == 0) {
663 /* MUST_SIGN already includes the MAY_SIGN FLAG
664 so if this is zero it means that signing is disabled */
665 cFYI(1, ("Signing disabled"));
666 if (server->secMode & SECMODE_SIGN_REQUIRED) {
667 cERROR(1, ("Server requires "
668 "packet signing to be enabled in "
669 "/proc/fs/cifs/SecurityFlags."));
670 rc = -EOPNOTSUPP;
671 }
672 server->secMode &=
673 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
674 } else if ((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) {
675 /* signing required */
676 cFYI(1, ("Must sign - secFlags 0x%x", secFlags));
677 if ((server->secMode &
678 (SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED)) == 0) {
679 cERROR(1,
680 ("signing required but server lacks support"));
681 rc = -EOPNOTSUPP;
682 } else
683 server->secMode |= SECMODE_SIGN_REQUIRED;
684 } else {
685 /* signing optional ie CIFSSEC_MAY_SIGN */
686 if ((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
687 server->secMode &=
688 ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
689 }
690
691 neg_err_exit:
692 cifs_buf_release(pSMB);
693
694 cFYI(1, ("negprot rc %d", rc));
695 return rc;
696 }
697
698 int
699 CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
700 {
701 struct smb_hdr *smb_buffer;
702 struct smb_hdr *smb_buffer_response; /* BB removeme BB */
703 int rc = 0;
704 int length;
705
706 cFYI(1, ("In tree disconnect"));
707 /*
708 * If last user of the connection and
709 * connection alive - disconnect it
710 * If this is the last connection on the server session disconnect it
711 * (and inside session disconnect we should check if tcp socket needs
712 * to be freed and kernel thread woken up).
713 */
714 if (tcon)
715 down(&tcon->tconSem);
716 else
717 return -EIO;
718
719 atomic_dec(&tcon->useCount);
720 if (atomic_read(&tcon->useCount) > 0) {
721 up(&tcon->tconSem);
722 return -EBUSY;
723 }
724
725 /* No need to return error on this operation if tid invalidated and
726 closed on server already e.g. due to tcp session crashing */
727 if (tcon->tidStatus == CifsNeedReconnect) {
728 up(&tcon->tconSem);
729 return 0;
730 }
731
732 if ((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
733 up(&tcon->tconSem);
734 return -EIO;
735 }
736 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
737 (void **)&smb_buffer);
738 if (rc) {
739 up(&tcon->tconSem);
740 return rc;
741 } else {
742 smb_buffer_response = smb_buffer; /* BB removeme BB */
743 }
744 rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
745 &length, 0);
746 if (rc)
747 cFYI(1, ("Tree disconnect failed %d", rc));
748
749 if (smb_buffer)
750 cifs_small_buf_release(smb_buffer);
751 up(&tcon->tconSem);
752
753 /* No need to return error on this operation if tid invalidated and
754 closed on server already e.g. due to tcp session crashing */
755 if (rc == -EAGAIN)
756 rc = 0;
757
758 return rc;
759 }
760
761 int
762 CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
763 {
764 struct smb_hdr *smb_buffer_response;
765 LOGOFF_ANDX_REQ *pSMB;
766 int rc = 0;
767 int length;
768
769 cFYI(1, ("In SMBLogoff for session disconnect"));
770 if (ses)
771 down(&ses->sesSem);
772 else
773 return -EIO;
774
775 atomic_dec(&ses->inUse);
776 if (atomic_read(&ses->inUse) > 0) {
777 up(&ses->sesSem);
778 return -EBUSY;
779 }
780 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
781 if (rc) {
782 up(&ses->sesSem);
783 return rc;
784 }
785
786 smb_buffer_response = (struct smb_hdr *)pSMB; /* BB removeme BB */
787
788 if (ses->server) {
789 pSMB->hdr.Mid = GetNextMid(ses->server);
790
791 if (ses->server->secMode &
792 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
793 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
794 }
795
796 pSMB->hdr.Uid = ses->Suid;
797
798 pSMB->AndXCommand = 0xFF;
799 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
800 smb_buffer_response, &length, 0);
801 if (ses->server) {
802 atomic_dec(&ses->server->socketUseCount);
803 if (atomic_read(&ses->server->socketUseCount) == 0) {
804 spin_lock(&GlobalMid_Lock);
805 ses->server->tcpStatus = CifsExiting;
806 spin_unlock(&GlobalMid_Lock);
807 rc = -ESHUTDOWN;
808 }
809 }
810 up(&ses->sesSem);
811 cifs_small_buf_release(pSMB);
812
813 /* if session dead then we do not need to do ulogoff,
814 since server closed smb session, no sense reporting
815 error */
816 if (rc == -EAGAIN)
817 rc = 0;
818 return rc;
819 }
820
821 int
822 CIFSPOSIXDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
823 __u16 type, const struct nls_table *nls_codepage, int remap)
824 {
825 TRANSACTION2_SPI_REQ *pSMB = NULL;
826 TRANSACTION2_SPI_RSP *pSMBr = NULL;
827 struct unlink_psx_rq *pRqD;
828 int name_len;
829 int rc = 0;
830 int bytes_returned = 0;
831 __u16 params, param_offset, offset, byte_count;
832
833 cFYI(1, ("In POSIX delete"));
834 PsxDelete:
835 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
836 (void **) &pSMBr);
837 if (rc)
838 return rc;
839
840 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
841 name_len =
842 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
843 PATH_MAX, nls_codepage, remap);
844 name_len++; /* trailing null */
845 name_len *= 2;
846 } else { /* BB add path length overrun check */
847 name_len = strnlen(fileName, PATH_MAX);
848 name_len++; /* trailing null */
849 strncpy(pSMB->FileName, fileName, name_len);
850 }
851
852 params = 6 + name_len;
853 pSMB->MaxParameterCount = cpu_to_le16(2);
854 pSMB->MaxDataCount = 0; /* BB double check this with jra */
855 pSMB->MaxSetupCount = 0;
856 pSMB->Reserved = 0;
857 pSMB->Flags = 0;
858 pSMB->Timeout = 0;
859 pSMB->Reserved2 = 0;
860 param_offset = offsetof(struct smb_com_transaction2_spi_req,
861 InformationLevel) - 4;
862 offset = param_offset + params;
863
864 /* Setup pointer to Request Data (inode type) */
865 pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
866 pRqD->type = cpu_to_le16(type);
867 pSMB->ParameterOffset = cpu_to_le16(param_offset);
868 pSMB->DataOffset = cpu_to_le16(offset);
869 pSMB->SetupCount = 1;
870 pSMB->Reserved3 = 0;
871 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
872 byte_count = 3 /* pad */ + params + sizeof(struct unlink_psx_rq);
873
874 pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
875 pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
876 pSMB->ParameterCount = cpu_to_le16(params);
877 pSMB->TotalParameterCount = pSMB->ParameterCount;
878 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
879 pSMB->Reserved4 = 0;
880 pSMB->hdr.smb_buf_length += byte_count;
881 pSMB->ByteCount = cpu_to_le16(byte_count);
882 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
883 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
884 if (rc) {
885 cFYI(1, ("Posix delete returned %d", rc));
886 }
887 cifs_buf_release(pSMB);
888
889 cifs_stats_inc(&tcon->num_deletes);
890
891 if (rc == -EAGAIN)
892 goto PsxDelete;
893
894 return rc;
895 }
896
897 int
898 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
899 const struct nls_table *nls_codepage, int remap)
900 {
901 DELETE_FILE_REQ *pSMB = NULL;
902 DELETE_FILE_RSP *pSMBr = NULL;
903 int rc = 0;
904 int bytes_returned;
905 int name_len;
906
907 DelFileRetry:
908 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
909 (void **) &pSMBr);
910 if (rc)
911 return rc;
912
913 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
914 name_len =
915 cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
916 PATH_MAX, nls_codepage, remap);
917 name_len++; /* trailing null */
918 name_len *= 2;
919 } else { /* BB improve check for buffer overruns BB */
920 name_len = strnlen(fileName, PATH_MAX);
921 name_len++; /* trailing null */
922 strncpy(pSMB->fileName, fileName, name_len);
923 }
924 pSMB->SearchAttributes =
925 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
926 pSMB->BufferFormat = 0x04;
927 pSMB->hdr.smb_buf_length += name_len + 1;
928 pSMB->ByteCount = cpu_to_le16(name_len + 1);
929 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
930 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
931 cifs_stats_inc(&tcon->num_deletes);
932 if (rc) {
933 cFYI(1, ("Error in RMFile = %d", rc));
934 }
935
936 cifs_buf_release(pSMB);
937 if (rc == -EAGAIN)
938 goto DelFileRetry;
939
940 return rc;
941 }
942
943 int
944 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
945 const struct nls_table *nls_codepage, int remap)
946 {
947 DELETE_DIRECTORY_REQ *pSMB = NULL;
948 DELETE_DIRECTORY_RSP *pSMBr = NULL;
949 int rc = 0;
950 int bytes_returned;
951 int name_len;
952
953 cFYI(1, ("In CIFSSMBRmDir"));
954 RmDirRetry:
955 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
956 (void **) &pSMBr);
957 if (rc)
958 return rc;
959
960 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
961 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
962 PATH_MAX, nls_codepage, remap);
963 name_len++; /* trailing null */
964 name_len *= 2;
965 } else { /* BB improve check for buffer overruns BB */
966 name_len = strnlen(dirName, PATH_MAX);
967 name_len++; /* trailing null */
968 strncpy(pSMB->DirName, dirName, name_len);
969 }
970
971 pSMB->BufferFormat = 0x04;
972 pSMB->hdr.smb_buf_length += name_len + 1;
973 pSMB->ByteCount = cpu_to_le16(name_len + 1);
974 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
975 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
976 cifs_stats_inc(&tcon->num_rmdirs);
977 if (rc) {
978 cFYI(1, ("Error in RMDir = %d", rc));
979 }
980
981 cifs_buf_release(pSMB);
982 if (rc == -EAGAIN)
983 goto RmDirRetry;
984 return rc;
985 }
986
987 int
988 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
989 const char *name, const struct nls_table *nls_codepage, int remap)
990 {
991 int rc = 0;
992 CREATE_DIRECTORY_REQ *pSMB = NULL;
993 CREATE_DIRECTORY_RSP *pSMBr = NULL;
994 int bytes_returned;
995 int name_len;
996
997 cFYI(1, ("In CIFSSMBMkDir"));
998 MkDirRetry:
999 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
1000 (void **) &pSMBr);
1001 if (rc)
1002 return rc;
1003
1004 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1005 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
1006 PATH_MAX, nls_codepage, remap);
1007 name_len++; /* trailing null */
1008 name_len *= 2;
1009 } else { /* BB improve check for buffer overruns BB */
1010 name_len = strnlen(name, PATH_MAX);
1011 name_len++; /* trailing null */
1012 strncpy(pSMB->DirName, name, name_len);
1013 }
1014
1015 pSMB->BufferFormat = 0x04;
1016 pSMB->hdr.smb_buf_length += name_len + 1;
1017 pSMB->ByteCount = cpu_to_le16(name_len + 1);
1018 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1019 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1020 cifs_stats_inc(&tcon->num_mkdirs);
1021 if (rc) {
1022 cFYI(1, ("Error in Mkdir = %d", rc));
1023 }
1024
1025 cifs_buf_release(pSMB);
1026 if (rc == -EAGAIN)
1027 goto MkDirRetry;
1028 return rc;
1029 }
1030
1031 int
1032 CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
1033 __u64 mode, __u16 * netfid, FILE_UNIX_BASIC_INFO *pRetData,
1034 __u32 *pOplock, const char *name,
1035 const struct nls_table *nls_codepage, int remap)
1036 {
1037 TRANSACTION2_SPI_REQ *pSMB = NULL;
1038 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1039 int name_len;
1040 int rc = 0;
1041 int bytes_returned = 0;
1042 __u16 params, param_offset, offset, byte_count, count;
1043 OPEN_PSX_REQ * pdata;
1044 OPEN_PSX_RSP * psx_rsp;
1045
1046 cFYI(1, ("In POSIX Create"));
1047 PsxCreat:
1048 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1049 (void **) &pSMBr);
1050 if (rc)
1051 return rc;
1052
1053 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1054 name_len =
1055 cifsConvertToUCS((__le16 *) pSMB->FileName, name,
1056 PATH_MAX, nls_codepage, remap);
1057 name_len++; /* trailing null */
1058 name_len *= 2;
1059 } else { /* BB improve the check for buffer overruns BB */
1060 name_len = strnlen(name, PATH_MAX);
1061 name_len++; /* trailing null */
1062 strncpy(pSMB->FileName, name, name_len);
1063 }
1064
1065 params = 6 + name_len;
1066 count = sizeof(OPEN_PSX_REQ);
1067 pSMB->MaxParameterCount = cpu_to_le16(2);
1068 pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1069 pSMB->MaxSetupCount = 0;
1070 pSMB->Reserved = 0;
1071 pSMB->Flags = 0;
1072 pSMB->Timeout = 0;
1073 pSMB->Reserved2 = 0;
1074 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1075 InformationLevel) - 4;
1076 offset = param_offset + params;
1077 pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1078 pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1079 pdata->Permissions = cpu_to_le64(mode);
1080 pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1081 pdata->OpenFlags = cpu_to_le32(*pOplock);
1082 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1083 pSMB->DataOffset = cpu_to_le16(offset);
1084 pSMB->SetupCount = 1;
1085 pSMB->Reserved3 = 0;
1086 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1087 byte_count = 3 /* pad */ + params + count;
1088
1089 pSMB->DataCount = cpu_to_le16(count);
1090 pSMB->ParameterCount = cpu_to_le16(params);
1091 pSMB->TotalDataCount = pSMB->DataCount;
1092 pSMB->TotalParameterCount = pSMB->ParameterCount;
1093 pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1094 pSMB->Reserved4 = 0;
1095 pSMB->hdr.smb_buf_length += byte_count;
1096 pSMB->ByteCount = cpu_to_le16(byte_count);
1097 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1098 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1099 if (rc) {
1100 cFYI(1, ("Posix create returned %d", rc));
1101 goto psx_create_err;
1102 }
1103
1104 cFYI(1, ("copying inode info"));
1105 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1106
1107 if (rc || (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP))) {
1108 rc = -EIO; /* bad smb */
1109 goto psx_create_err;
1110 }
1111
1112 /* copy return information to pRetData */
1113 psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1114 + le16_to_cpu(pSMBr->t2.DataOffset));
1115
1116 *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1117 if (netfid)
1118 *netfid = psx_rsp->Fid; /* cifs fid stays in le */
1119 /* Let caller know file was created so we can set the mode. */
1120 /* Do we care about the CreateAction in any other cases? */
1121 if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1122 *pOplock |= CIFS_CREATE_ACTION;
1123 /* check to make sure response data is there */
1124 if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1125 pRetData->Type = cpu_to_le32(-1); /* unknown */
1126 #ifdef CONFIG_CIFS_DEBUG2
1127 cFYI(1, ("unknown type"));
1128 #endif
1129 } else {
1130 if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
1131 + sizeof(FILE_UNIX_BASIC_INFO)) {
1132 cERROR(1, ("Open response data too small"));
1133 pRetData->Type = cpu_to_le32(-1);
1134 goto psx_create_err;
1135 }
1136 memcpy((char *) pRetData,
1137 (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1138 sizeof(FILE_UNIX_BASIC_INFO));
1139 }
1140
1141 psx_create_err:
1142 cifs_buf_release(pSMB);
1143
1144 cifs_stats_inc(&tcon->num_mkdirs);
1145
1146 if (rc == -EAGAIN)
1147 goto PsxCreat;
1148
1149 return rc;
1150 }
1151
1152 static __u16 convert_disposition(int disposition)
1153 {
1154 __u16 ofun = 0;
1155
1156 switch (disposition) {
1157 case FILE_SUPERSEDE:
1158 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1159 break;
1160 case FILE_OPEN:
1161 ofun = SMBOPEN_OAPPEND;
1162 break;
1163 case FILE_CREATE:
1164 ofun = SMBOPEN_OCREATE;
1165 break;
1166 case FILE_OPEN_IF:
1167 ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1168 break;
1169 case FILE_OVERWRITE:
1170 ofun = SMBOPEN_OTRUNC;
1171 break;
1172 case FILE_OVERWRITE_IF:
1173 ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1174 break;
1175 default:
1176 cFYI(1, ("unknown disposition %d", disposition));
1177 ofun = SMBOPEN_OAPPEND; /* regular open */
1178 }
1179 return ofun;
1180 }
1181
1182 int
1183 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
1184 const char *fileName, const int openDisposition,
1185 const int access_flags, const int create_options, __u16 * netfid,
1186 int *pOplock, FILE_ALL_INFO * pfile_info,
1187 const struct nls_table *nls_codepage, int remap)
1188 {
1189 int rc = -EACCES;
1190 OPENX_REQ *pSMB = NULL;
1191 OPENX_RSP *pSMBr = NULL;
1192 int bytes_returned;
1193 int name_len;
1194 __u16 count;
1195
1196 OldOpenRetry:
1197 rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1198 (void **) &pSMBr);
1199 if (rc)
1200 return rc;
1201
1202 pSMB->AndXCommand = 0xFF; /* none */
1203
1204 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1205 count = 1; /* account for one byte pad to word boundary */
1206 name_len =
1207 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1208 fileName, PATH_MAX, nls_codepage, remap);
1209 name_len++; /* trailing null */
1210 name_len *= 2;
1211 } else { /* BB improve check for buffer overruns BB */
1212 count = 0; /* no pad */
1213 name_len = strnlen(fileName, PATH_MAX);
1214 name_len++; /* trailing null */
1215 strncpy(pSMB->fileName, fileName, name_len);
1216 }
1217 if (*pOplock & REQ_OPLOCK)
1218 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1219 else if (*pOplock & REQ_BATCHOPLOCK)
1220 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1221
1222 pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1223 /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
1224 /* 0 = read
1225 1 = write
1226 2 = rw
1227 3 = execute
1228 */
1229 pSMB->Mode = cpu_to_le16(2);
1230 pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1231 /* set file as system file if special file such
1232 as fifo and server expecting SFU style and
1233 no Unix extensions */
1234
1235 if (create_options & CREATE_OPTION_SPECIAL)
1236 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1237 else
1238 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); /* BB FIXME */
1239
1240 /* if ((omode & S_IWUGO) == 0)
1241 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1242 /* Above line causes problems due to vfs splitting create into two
1243 pieces - need to set mode after file created not while it is
1244 being created */
1245
1246 /* BB FIXME BB */
1247 /* pSMB->CreateOptions = cpu_to_le32(create_options &
1248 CREATE_OPTIONS_MASK); */
1249 /* BB FIXME END BB */
1250
1251 pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1252 pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1253 count += name_len;
1254 pSMB->hdr.smb_buf_length += count;
1255
1256 pSMB->ByteCount = cpu_to_le16(count);
1257 /* long_op set to 1 to allow for oplock break timeouts */
1258 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1259 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
1260 cifs_stats_inc(&tcon->num_opens);
1261 if (rc) {
1262 cFYI(1, ("Error in Open = %d", rc));
1263 } else {
1264 /* BB verify if wct == 15 */
1265
1266 /* *pOplock = pSMBr->OplockLevel; */ /* BB take from action field BB */
1267
1268 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1269 /* Let caller know file was created so we can set the mode. */
1270 /* Do we care about the CreateAction in any other cases? */
1271 /* BB FIXME BB */
1272 /* if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1273 *pOplock |= CIFS_CREATE_ACTION; */
1274 /* BB FIXME END */
1275
1276 if (pfile_info) {
1277 pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1278 pfile_info->LastAccessTime = 0; /* BB fixme */
1279 pfile_info->LastWriteTime = 0; /* BB fixme */
1280 pfile_info->ChangeTime = 0; /* BB fixme */
1281 pfile_info->Attributes =
1282 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1283 /* the file_info buf is endian converted by caller */
1284 pfile_info->AllocationSize =
1285 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1286 pfile_info->EndOfFile = pfile_info->AllocationSize;
1287 pfile_info->NumberOfLinks = cpu_to_le32(1);
1288 }
1289 }
1290
1291 cifs_buf_release(pSMB);
1292 if (rc == -EAGAIN)
1293 goto OldOpenRetry;
1294 return rc;
1295 }
1296
1297 int
1298 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
1299 const char *fileName, const int openDisposition,
1300 const int access_flags, const int create_options, __u16 * netfid,
1301 int *pOplock, FILE_ALL_INFO * pfile_info,
1302 const struct nls_table *nls_codepage, int remap)
1303 {
1304 int rc = -EACCES;
1305 OPEN_REQ *pSMB = NULL;
1306 OPEN_RSP *pSMBr = NULL;
1307 int bytes_returned;
1308 int name_len;
1309 __u16 count;
1310
1311 openRetry:
1312 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1313 (void **) &pSMBr);
1314 if (rc)
1315 return rc;
1316
1317 pSMB->AndXCommand = 0xFF; /* none */
1318
1319 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1320 count = 1; /* account for one byte pad to word boundary */
1321 name_len =
1322 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1323 fileName, PATH_MAX, nls_codepage, remap);
1324 name_len++; /* trailing null */
1325 name_len *= 2;
1326 pSMB->NameLength = cpu_to_le16(name_len);
1327 } else { /* BB improve check for buffer overruns BB */
1328 count = 0; /* no pad */
1329 name_len = strnlen(fileName, PATH_MAX);
1330 name_len++; /* trailing null */
1331 pSMB->NameLength = cpu_to_le16(name_len);
1332 strncpy(pSMB->fileName, fileName, name_len);
1333 }
1334 if (*pOplock & REQ_OPLOCK)
1335 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1336 else if (*pOplock & REQ_BATCHOPLOCK)
1337 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1338 pSMB->DesiredAccess = cpu_to_le32(access_flags);
1339 pSMB->AllocationSize = 0;
1340 /* set file as system file if special file such
1341 as fifo and server expecting SFU style and
1342 no Unix extensions */
1343 if (create_options & CREATE_OPTION_SPECIAL)
1344 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1345 else
1346 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1347 /* XP does not handle ATTR_POSIX_SEMANTICS */
1348 /* but it helps speed up case sensitive checks for other
1349 servers such as Samba */
1350 if (tcon->ses->capabilities & CAP_UNIX)
1351 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1352
1353 /* if ((omode & S_IWUGO) == 0)
1354 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1355 /* Above line causes problems due to vfs splitting create into two
1356 pieces - need to set mode after file created not while it is
1357 being created */
1358 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1359 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1360 pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1361 /* BB Expirement with various impersonation levels and verify */
1362 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1363 pSMB->SecurityFlags =
1364 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1365
1366 count += name_len;
1367 pSMB->hdr.smb_buf_length += count;
1368
1369 pSMB->ByteCount = cpu_to_le16(count);
1370 /* long_op set to 1 to allow for oplock break timeouts */
1371 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1372 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
1373 cifs_stats_inc(&tcon->num_opens);
1374 if (rc) {
1375 cFYI(1, ("Error in Open = %d", rc));
1376 } else {
1377 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1378 *netfid = pSMBr->Fid; /* cifs fid stays in le */
1379 /* Let caller know file was created so we can set the mode. */
1380 /* Do we care about the CreateAction in any other cases? */
1381 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1382 *pOplock |= CIFS_CREATE_ACTION;
1383 if (pfile_info) {
1384 memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1385 36 /* CreationTime to Attributes */);
1386 /* the file_info buf is endian converted by caller */
1387 pfile_info->AllocationSize = pSMBr->AllocationSize;
1388 pfile_info->EndOfFile = pSMBr->EndOfFile;
1389 pfile_info->NumberOfLinks = cpu_to_le32(1);
1390 }
1391 }
1392
1393 cifs_buf_release(pSMB);
1394 if (rc == -EAGAIN)
1395 goto openRetry;
1396 return rc;
1397 }
1398
1399 int
1400 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
1401 const unsigned int count, const __u64 lseek, unsigned int *nbytes,
1402 char **buf, int *pbuf_type)
1403 {
1404 int rc = -EACCES;
1405 READ_REQ *pSMB = NULL;
1406 READ_RSP *pSMBr = NULL;
1407 char *pReadData = NULL;
1408 int wct;
1409 int resp_buf_type = 0;
1410 struct kvec iov[1];
1411
1412 cFYI(1, ("Reading %d bytes on fid %d", count, netfid));
1413 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1414 wct = 12;
1415 else
1416 wct = 10; /* old style read */
1417
1418 *nbytes = 0;
1419 rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1420 if (rc)
1421 return rc;
1422
1423 /* tcon and ses pointer are checked in smb_init */
1424 if (tcon->ses->server == NULL)
1425 return -ECONNABORTED;
1426
1427 pSMB->AndXCommand = 0xFF; /* none */
1428 pSMB->Fid = netfid;
1429 pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
1430 if (wct == 12)
1431 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
1432 else if ((lseek >> 32) > 0) /* can not handle this big offset for old */
1433 return -EIO;
1434
1435 pSMB->Remaining = 0;
1436 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1437 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1438 if (wct == 12)
1439 pSMB->ByteCount = 0; /* no need to do le conversion since 0 */
1440 else {
1441 /* old style read */
1442 struct smb_com_readx_req *pSMBW =
1443 (struct smb_com_readx_req *)pSMB;
1444 pSMBW->ByteCount = 0;
1445 }
1446
1447 iov[0].iov_base = (char *)pSMB;
1448 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1449 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1450 &resp_buf_type, 0 /* not long op */, 1 /* log err */ );
1451 cifs_stats_inc(&tcon->num_reads);
1452 pSMBr = (READ_RSP *)iov[0].iov_base;
1453 if (rc) {
1454 cERROR(1, ("Send error in read = %d", rc));
1455 } else {
1456 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1457 data_length = data_length << 16;
1458 data_length += le16_to_cpu(pSMBr->DataLength);
1459 *nbytes = data_length;
1460
1461 /*check that DataLength would not go beyond end of SMB */
1462 if ((data_length > CIFSMaxBufSize)
1463 || (data_length > count)) {
1464 cFYI(1, ("bad length %d for count %d",
1465 data_length, count));
1466 rc = -EIO;
1467 *nbytes = 0;
1468 } else {
1469 pReadData = (char *) (&pSMBr->hdr.Protocol) +
1470 le16_to_cpu(pSMBr->DataOffset);
1471 /* if (rc = copy_to_user(buf, pReadData, data_length)) {
1472 cERROR(1,("Faulting on read rc = %d",rc));
1473 rc = -EFAULT;
1474 }*/ /* can not use copy_to_user when using page cache*/
1475 if (*buf)
1476 memcpy(*buf, pReadData, data_length);
1477 }
1478 }
1479
1480 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1481 if (*buf) {
1482 if (resp_buf_type == CIFS_SMALL_BUFFER)
1483 cifs_small_buf_release(iov[0].iov_base);
1484 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1485 cifs_buf_release(iov[0].iov_base);
1486 } else if (resp_buf_type != CIFS_NO_BUFFER) {
1487 /* return buffer to caller to free */
1488 *buf = iov[0].iov_base;
1489 if (resp_buf_type == CIFS_SMALL_BUFFER)
1490 *pbuf_type = CIFS_SMALL_BUFFER;
1491 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1492 *pbuf_type = CIFS_LARGE_BUFFER;
1493 } /* else no valid buffer on return - leave as null */
1494
1495 /* Note: On -EAGAIN error only caller can retry on handle based calls
1496 since file handle passed in no longer valid */
1497 return rc;
1498 }
1499
1500
1501 int
1502 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
1503 const int netfid, const unsigned int count,
1504 const __u64 offset, unsigned int *nbytes, const char *buf,
1505 const char __user *ubuf, const int long_op)
1506 {
1507 int rc = -EACCES;
1508 WRITE_REQ *pSMB = NULL;
1509 WRITE_RSP *pSMBr = NULL;
1510 int bytes_returned, wct;
1511 __u32 bytes_sent;
1512 __u16 byte_count;
1513
1514 /* cFYI(1,("write at %lld %d bytes",offset,count));*/
1515 if (tcon->ses == NULL)
1516 return -ECONNABORTED;
1517
1518 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1519 wct = 14;
1520 else
1521 wct = 12;
1522
1523 rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1524 (void **) &pSMBr);
1525 if (rc)
1526 return rc;
1527 /* tcon and ses pointer are checked in smb_init */
1528 if (tcon->ses->server == NULL)
1529 return -ECONNABORTED;
1530
1531 pSMB->AndXCommand = 0xFF; /* none */
1532 pSMB->Fid = netfid;
1533 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1534 if (wct == 14)
1535 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1536 else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1537 return -EIO;
1538
1539 pSMB->Reserved = 0xFFFFFFFF;
1540 pSMB->WriteMode = 0;
1541 pSMB->Remaining = 0;
1542
1543 /* Can increase buffer size if buffer is big enough in some cases ie we
1544 can send more if LARGE_WRITE_X capability returned by the server and if
1545 our buffer is big enough or if we convert to iovecs on socket writes
1546 and eliminate the copy to the CIFS buffer */
1547 if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1548 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1549 } else {
1550 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1551 & ~0xFF;
1552 }
1553
1554 if (bytes_sent > count)
1555 bytes_sent = count;
1556 pSMB->DataOffset =
1557 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1558 if (buf)
1559 memcpy(pSMB->Data, buf, bytes_sent);
1560 else if (ubuf) {
1561 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1562 cifs_buf_release(pSMB);
1563 return -EFAULT;
1564 }
1565 } else if (count != 0) {
1566 /* No buffer */
1567 cifs_buf_release(pSMB);
1568 return -EINVAL;
1569 } /* else setting file size with write of zero bytes */
1570 if (wct == 14)
1571 byte_count = bytes_sent + 1; /* pad */
1572 else /* wct == 12 */ {
1573 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1574 }
1575 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1576 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1577 pSMB->hdr.smb_buf_length += byte_count;
1578
1579 if (wct == 14)
1580 pSMB->ByteCount = cpu_to_le16(byte_count);
1581 else { /* old style write has byte count 4 bytes earlier
1582 so 4 bytes pad */
1583 struct smb_com_writex_req *pSMBW =
1584 (struct smb_com_writex_req *)pSMB;
1585 pSMBW->ByteCount = cpu_to_le16(byte_count);
1586 }
1587
1588 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1589 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1590 cifs_stats_inc(&tcon->num_writes);
1591 if (rc) {
1592 cFYI(1, ("Send error in write = %d", rc));
1593 *nbytes = 0;
1594 } else {
1595 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1596 *nbytes = (*nbytes) << 16;
1597 *nbytes += le16_to_cpu(pSMBr->Count);
1598 }
1599
1600 cifs_buf_release(pSMB);
1601
1602 /* Note: On -EAGAIN error only caller can retry on handle based calls
1603 since file handle passed in no longer valid */
1604
1605 return rc;
1606 }
1607
1608 int
1609 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
1610 const int netfid, const unsigned int count,
1611 const __u64 offset, unsigned int *nbytes, struct kvec *iov,
1612 int n_vec, const int long_op)
1613 {
1614 int rc = -EACCES;
1615 WRITE_REQ *pSMB = NULL;
1616 int wct;
1617 int smb_hdr_len;
1618 int resp_buf_type = 0;
1619
1620 cFYI(1, ("write2 at %lld %d bytes", (long long)offset, count));
1621
1622 if (tcon->ses->capabilities & CAP_LARGE_FILES)
1623 wct = 14;
1624 else
1625 wct = 12;
1626 rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1627 if (rc)
1628 return rc;
1629 /* tcon and ses pointer are checked in smb_init */
1630 if (tcon->ses->server == NULL)
1631 return -ECONNABORTED;
1632
1633 pSMB->AndXCommand = 0xFF; /* none */
1634 pSMB->Fid = netfid;
1635 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1636 if (wct == 14)
1637 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1638 else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1639 return -EIO;
1640 pSMB->Reserved = 0xFFFFFFFF;
1641 pSMB->WriteMode = 0;
1642 pSMB->Remaining = 0;
1643
1644 pSMB->DataOffset =
1645 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1646
1647 pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1648 pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1649 smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1650 if (wct == 14)
1651 pSMB->hdr.smb_buf_length += count+1;
1652 else /* wct == 12 */
1653 pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
1654 if (wct == 14)
1655 pSMB->ByteCount = cpu_to_le16(count + 1);
1656 else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1657 struct smb_com_writex_req *pSMBW =
1658 (struct smb_com_writex_req *)pSMB;
1659 pSMBW->ByteCount = cpu_to_le16(count + 5);
1660 }
1661 iov[0].iov_base = pSMB;
1662 if (wct == 14)
1663 iov[0].iov_len = smb_hdr_len + 4;
1664 else /* wct == 12 pad bigger by four bytes */
1665 iov[0].iov_len = smb_hdr_len + 8;
1666
1667
1668 rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
1669 long_op, 0 /* do not log STATUS code */ );
1670 cifs_stats_inc(&tcon->num_writes);
1671 if (rc) {
1672 cFYI(1, ("Send error Write2 = %d", rc));
1673 *nbytes = 0;
1674 } else if (resp_buf_type == 0) {
1675 /* presumably this can not happen, but best to be safe */
1676 rc = -EIO;
1677 *nbytes = 0;
1678 } else {
1679 WRITE_RSP * pSMBr = (WRITE_RSP *)iov[0].iov_base;
1680 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1681 *nbytes = (*nbytes) << 16;
1682 *nbytes += le16_to_cpu(pSMBr->Count);
1683 }
1684
1685 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1686 if (resp_buf_type == CIFS_SMALL_BUFFER)
1687 cifs_small_buf_release(iov[0].iov_base);
1688 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1689 cifs_buf_release(iov[0].iov_base);
1690
1691 /* Note: On -EAGAIN error only caller can retry on handle based calls
1692 since file handle passed in no longer valid */
1693
1694 return rc;
1695 }
1696
1697
1698 int
1699 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1700 const __u16 smb_file_id, const __u64 len,
1701 const __u64 offset, const __u32 numUnlock,
1702 const __u32 numLock, const __u8 lockType, const int waitFlag)
1703 {
1704 int rc = 0;
1705 LOCK_REQ *pSMB = NULL;
1706 LOCK_RSP *pSMBr = NULL;
1707 int bytes_returned;
1708 int timeout = 0;
1709 __u16 count;
1710
1711 cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d", waitFlag, numLock));
1712 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1713
1714 if (rc)
1715 return rc;
1716
1717 pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
1718
1719 if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1720 timeout = -1; /* no response expected */
1721 pSMB->Timeout = 0;
1722 } else if (waitFlag == TRUE) {
1723 timeout = 3; /* blocking operation, no timeout */
1724 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1725 } else {
1726 pSMB->Timeout = 0;
1727 }
1728
1729 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1730 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1731 pSMB->LockType = lockType;
1732 pSMB->AndXCommand = 0xFF; /* none */
1733 pSMB->Fid = smb_file_id; /* netfid stays le */
1734
1735 if ((numLock != 0) || (numUnlock != 0)) {
1736 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1737 /* BB where to store pid high? */
1738 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1739 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1740 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1741 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1742 count = sizeof(LOCKING_ANDX_RANGE);
1743 } else {
1744 /* oplock break */
1745 count = 0;
1746 }
1747 pSMB->hdr.smb_buf_length += count;
1748 pSMB->ByteCount = cpu_to_le16(count);
1749
1750 if (waitFlag) {
1751 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1752 (struct smb_hdr *) pSMBr, &bytes_returned);
1753 } else {
1754 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1755 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1756 }
1757 cifs_stats_inc(&tcon->num_locks);
1758 if (rc) {
1759 cFYI(1, ("Send error in Lock = %d", rc));
1760 }
1761 cifs_small_buf_release(pSMB);
1762
1763 /* Note: On -EAGAIN error only caller can retry on handle based calls
1764 since file handle passed in no longer valid */
1765 return rc;
1766 }
1767
1768 int
1769 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
1770 const __u16 smb_file_id, const int get_flag, const __u64 len,
1771 struct file_lock *pLockData, const __u16 lock_type,
1772 const int waitFlag)
1773 {
1774 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1775 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1776 struct cifs_posix_lock *parm_data;
1777 int rc = 0;
1778 int timeout = 0;
1779 int bytes_returned = 0;
1780 __u16 params, param_offset, offset, byte_count, count;
1781
1782 cFYI(1, ("Posix Lock"));
1783
1784 if (pLockData == NULL)
1785 return EINVAL;
1786
1787 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1788
1789 if (rc)
1790 return rc;
1791
1792 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1793
1794 params = 6;
1795 pSMB->MaxSetupCount = 0;
1796 pSMB->Reserved = 0;
1797 pSMB->Flags = 0;
1798 pSMB->Reserved2 = 0;
1799 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1800 offset = param_offset + params;
1801
1802 count = sizeof(struct cifs_posix_lock);
1803 pSMB->MaxParameterCount = cpu_to_le16(2);
1804 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1805 pSMB->SetupCount = 1;
1806 pSMB->Reserved3 = 0;
1807 if (get_flag)
1808 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
1809 else
1810 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1811 byte_count = 3 /* pad */ + params + count;
1812 pSMB->DataCount = cpu_to_le16(count);
1813 pSMB->ParameterCount = cpu_to_le16(params);
1814 pSMB->TotalDataCount = pSMB->DataCount;
1815 pSMB->TotalParameterCount = pSMB->ParameterCount;
1816 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1817 parm_data = (struct cifs_posix_lock *)
1818 (((char *) &pSMB->hdr.Protocol) + offset);
1819
1820 parm_data->lock_type = cpu_to_le16(lock_type);
1821 if (waitFlag) {
1822 timeout = 3; /* blocking operation, no timeout */
1823 parm_data->lock_flags = cpu_to_le16(1);
1824 pSMB->Timeout = cpu_to_le32(-1);
1825 } else
1826 pSMB->Timeout = 0;
1827
1828 parm_data->pid = cpu_to_le32(current->tgid);
1829 parm_data->start = cpu_to_le64(pLockData->fl_start);
1830 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
1831
1832 pSMB->DataOffset = cpu_to_le16(offset);
1833 pSMB->Fid = smb_file_id;
1834 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
1835 pSMB->Reserved4 = 0;
1836 pSMB->hdr.smb_buf_length += byte_count;
1837 pSMB->ByteCount = cpu_to_le16(byte_count);
1838 if (waitFlag) {
1839 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1840 (struct smb_hdr *) pSMBr, &bytes_returned);
1841 } else {
1842 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1843 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1844 }
1845
1846 if (rc) {
1847 cFYI(1, ("Send error in Posix Lock = %d", rc));
1848 } else if (get_flag) {
1849 /* lock structure can be returned on get */
1850 __u16 data_offset;
1851 __u16 data_count;
1852 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1853
1854 if (rc || (pSMBr->ByteCount < sizeof(struct cifs_posix_lock))) {
1855 rc = -EIO; /* bad smb */
1856 goto plk_err_exit;
1857 }
1858 if (pLockData == NULL) {
1859 rc = -EINVAL;
1860 goto plk_err_exit;
1861 }
1862 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1863 data_count = le16_to_cpu(pSMBr->t2.DataCount);
1864 if (data_count < sizeof(struct cifs_posix_lock)) {
1865 rc = -EIO;
1866 goto plk_err_exit;
1867 }
1868 parm_data = (struct cifs_posix_lock *)
1869 ((char *)&pSMBr->hdr.Protocol + data_offset);
1870 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
1871 pLockData->fl_type = F_UNLCK;
1872 }
1873
1874 plk_err_exit:
1875 if (pSMB)
1876 cifs_small_buf_release(pSMB);
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 CLOSE_RSP *pSMBr = NULL;
1891 int bytes_returned;
1892 cFYI(1, ("In CIFSSMBClose"));
1893
1894 /* do not retry on dead session on close */
1895 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1896 if (rc == -EAGAIN)
1897 return 0;
1898 if (rc)
1899 return rc;
1900
1901 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
1902
1903 pSMB->FileID = (__u16) smb_file_id;
1904 pSMB->LastWriteTime = 0xFFFFFFFF;
1905 pSMB->ByteCount = 0;
1906 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1907 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1908 cifs_stats_inc(&tcon->num_closes);
1909 if (rc) {
1910 if (rc != -EINTR) {
1911 /* EINTR is expected when user ctl-c to kill app */
1912 cERROR(1, ("Send error in Close = %d", rc));
1913 }
1914 }
1915
1916 cifs_small_buf_release(pSMB);
1917
1918 /* Since session is dead, file will be closed on server already */
1919 if (rc == -EAGAIN)
1920 rc = 0;
1921
1922 return rc;
1923 }
1924
1925 int
1926 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1927 const char *fromName, const char *toName,
1928 const struct nls_table *nls_codepage, int remap)
1929 {
1930 int rc = 0;
1931 RENAME_REQ *pSMB = NULL;
1932 RENAME_RSP *pSMBr = NULL;
1933 int bytes_returned;
1934 int name_len, name_len2;
1935 __u16 count;
1936
1937 cFYI(1, ("In CIFSSMBRename"));
1938 renameRetry:
1939 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1940 (void **) &pSMBr);
1941 if (rc)
1942 return rc;
1943
1944 pSMB->BufferFormat = 0x04;
1945 pSMB->SearchAttributes =
1946 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1947 ATTR_DIRECTORY);
1948
1949 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1950 name_len =
1951 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1952 PATH_MAX, nls_codepage, remap);
1953 name_len++; /* trailing null */
1954 name_len *= 2;
1955 pSMB->OldFileName[name_len] = 0x04; /* pad */
1956 /* protocol requires ASCII signature byte on Unicode string */
1957 pSMB->OldFileName[name_len + 1] = 0x00;
1958 name_len2 =
1959 cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1960 toName, PATH_MAX, nls_codepage, remap);
1961 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1962 name_len2 *= 2; /* convert to bytes */
1963 } else { /* BB improve the check for buffer overruns BB */
1964 name_len = strnlen(fromName, PATH_MAX);
1965 name_len++; /* trailing null */
1966 strncpy(pSMB->OldFileName, fromName, name_len);
1967 name_len2 = strnlen(toName, PATH_MAX);
1968 name_len2++; /* trailing null */
1969 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1970 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1971 name_len2++; /* trailing null */
1972 name_len2++; /* signature byte */
1973 }
1974
1975 count = 1 /* 1st signature byte */ + name_len + name_len2;
1976 pSMB->hdr.smb_buf_length += count;
1977 pSMB->ByteCount = cpu_to_le16(count);
1978
1979 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1980 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1981 cifs_stats_inc(&tcon->num_renames);
1982 if (rc) {
1983 cFYI(1, ("Send error in rename = %d", rc));
1984 }
1985
1986 cifs_buf_release(pSMB);
1987
1988 if (rc == -EAGAIN)
1989 goto renameRetry;
1990
1991 return rc;
1992 }
1993
1994 int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
1995 int netfid, char *target_name,
1996 const struct nls_table *nls_codepage, int remap)
1997 {
1998 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1999 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2000 struct set_file_rename *rename_info;
2001 char *data_offset;
2002 char dummy_string[30];
2003 int rc = 0;
2004 int bytes_returned = 0;
2005 int len_of_str;
2006 __u16 params, param_offset, offset, count, byte_count;
2007
2008 cFYI(1, ("Rename to File by handle"));
2009 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2010 (void **) &pSMBr);
2011 if (rc)
2012 return rc;
2013
2014 params = 6;
2015 pSMB->MaxSetupCount = 0;
2016 pSMB->Reserved = 0;
2017 pSMB->Flags = 0;
2018 pSMB->Timeout = 0;
2019 pSMB->Reserved2 = 0;
2020 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2021 offset = param_offset + params;
2022
2023 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2024 rename_info = (struct set_file_rename *) data_offset;
2025 pSMB->MaxParameterCount = cpu_to_le16(2);
2026 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
2027 pSMB->SetupCount = 1;
2028 pSMB->Reserved3 = 0;
2029 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2030 byte_count = 3 /* pad */ + params;
2031 pSMB->ParameterCount = cpu_to_le16(params);
2032 pSMB->TotalParameterCount = pSMB->ParameterCount;
2033 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2034 pSMB->DataOffset = cpu_to_le16(offset);
2035 /* construct random name ".cifs_tmp<inodenum><mid>" */
2036 rename_info->overwrite = cpu_to_le32(1);
2037 rename_info->root_fid = 0;
2038 /* unicode only call */
2039 if (target_name == NULL) {
2040 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2041 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2042 dummy_string, 24, nls_codepage, remap);
2043 } else {
2044 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2045 target_name, PATH_MAX, nls_codepage,
2046 remap);
2047 }
2048 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2049 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
2050 byte_count += count;
2051 pSMB->DataCount = cpu_to_le16(count);
2052 pSMB->TotalDataCount = pSMB->DataCount;
2053 pSMB->Fid = netfid;
2054 pSMB->InformationLevel =
2055 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2056 pSMB->Reserved4 = 0;
2057 pSMB->hdr.smb_buf_length += byte_count;
2058 pSMB->ByteCount = cpu_to_le16(byte_count);
2059 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2060 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2061 cifs_stats_inc(&pTcon->num_t2renames);
2062 if (rc) {
2063 cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
2064 }
2065
2066 cifs_buf_release(pSMB);
2067
2068 /* Note: On -EAGAIN error only caller can retry on handle based calls
2069 since file handle passed in no longer valid */
2070
2071 return rc;
2072 }
2073
2074 int
2075 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char *fromName,
2076 const __u16 target_tid, const char *toName, const int flags,
2077 const struct nls_table *nls_codepage, int remap)
2078 {
2079 int rc = 0;
2080 COPY_REQ *pSMB = NULL;
2081 COPY_RSP *pSMBr = NULL;
2082 int bytes_returned;
2083 int name_len, name_len2;
2084 __u16 count;
2085
2086 cFYI(1, ("In CIFSSMBCopy"));
2087 copyRetry:
2088 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2089 (void **) &pSMBr);
2090 if (rc)
2091 return rc;
2092
2093 pSMB->BufferFormat = 0x04;
2094 pSMB->Tid2 = target_tid;
2095
2096 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2097
2098 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2099 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
2100 fromName, PATH_MAX, nls_codepage,
2101 remap);
2102 name_len++; /* trailing null */
2103 name_len *= 2;
2104 pSMB->OldFileName[name_len] = 0x04; /* pad */
2105 /* protocol requires ASCII signature byte on Unicode string */
2106 pSMB->OldFileName[name_len + 1] = 0x00;
2107 name_len2 =
2108 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2109 toName, PATH_MAX, nls_codepage, remap);
2110 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2111 name_len2 *= 2; /* convert to bytes */
2112 } else { /* BB improve the check for buffer overruns BB */
2113 name_len = strnlen(fromName, PATH_MAX);
2114 name_len++; /* trailing null */
2115 strncpy(pSMB->OldFileName, fromName, name_len);
2116 name_len2 = strnlen(toName, PATH_MAX);
2117 name_len2++; /* trailing null */
2118 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2119 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2120 name_len2++; /* trailing null */
2121 name_len2++; /* signature byte */
2122 }
2123
2124 count = 1 /* 1st signature byte */ + name_len + name_len2;
2125 pSMB->hdr.smb_buf_length += count;
2126 pSMB->ByteCount = cpu_to_le16(count);
2127
2128 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2129 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2130 if (rc) {
2131 cFYI(1, ("Send error in copy = %d with %d files copied",
2132 rc, le16_to_cpu(pSMBr->CopyCount)));
2133 }
2134 if (pSMB)
2135 cifs_buf_release(pSMB);
2136
2137 if (rc == -EAGAIN)
2138 goto copyRetry;
2139
2140 return rc;
2141 }
2142
2143 int
2144 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
2145 const char *fromName, const char *toName,
2146 const struct nls_table *nls_codepage)
2147 {
2148 TRANSACTION2_SPI_REQ *pSMB = NULL;
2149 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2150 char *data_offset;
2151 int name_len;
2152 int name_len_target;
2153 int rc = 0;
2154 int bytes_returned = 0;
2155 __u16 params, param_offset, offset, byte_count;
2156
2157 cFYI(1, ("In Symlink Unix style"));
2158 createSymLinkRetry:
2159 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2160 (void **) &pSMBr);
2161 if (rc)
2162 return rc;
2163
2164 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2165 name_len =
2166 cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
2167 /* find define for this maxpathcomponent */
2168 , nls_codepage);
2169 name_len++; /* trailing null */
2170 name_len *= 2;
2171
2172 } else { /* BB improve the check for buffer overruns BB */
2173 name_len = strnlen(fromName, PATH_MAX);
2174 name_len++; /* trailing null */
2175 strncpy(pSMB->FileName, fromName, name_len);
2176 }
2177 params = 6 + name_len;
2178 pSMB->MaxSetupCount = 0;
2179 pSMB->Reserved = 0;
2180 pSMB->Flags = 0;
2181 pSMB->Timeout = 0;
2182 pSMB->Reserved2 = 0;
2183 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2184 InformationLevel) - 4;
2185 offset = param_offset + params;
2186
2187 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2188 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2189 name_len_target =
2190 cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
2191 /* find define for this maxpathcomponent */
2192 , nls_codepage);
2193 name_len_target++; /* trailing null */
2194 name_len_target *= 2;
2195 } else { /* BB improve the check for buffer overruns BB */
2196 name_len_target = strnlen(toName, PATH_MAX);
2197 name_len_target++; /* trailing null */
2198 strncpy(data_offset, toName, name_len_target);
2199 }
2200
2201 pSMB->MaxParameterCount = cpu_to_le16(2);
2202 /* BB find exact max on data count below from sess */
2203 pSMB->MaxDataCount = cpu_to_le16(1000);
2204 pSMB->SetupCount = 1;
2205 pSMB->Reserved3 = 0;
2206 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2207 byte_count = 3 /* pad */ + params + name_len_target;
2208 pSMB->DataCount = cpu_to_le16(name_len_target);
2209 pSMB->ParameterCount = cpu_to_le16(params);
2210 pSMB->TotalDataCount = pSMB->DataCount;
2211 pSMB->TotalParameterCount = pSMB->ParameterCount;
2212 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2213 pSMB->DataOffset = cpu_to_le16(offset);
2214 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2215 pSMB->Reserved4 = 0;
2216 pSMB->hdr.smb_buf_length += byte_count;
2217 pSMB->ByteCount = cpu_to_le16(byte_count);
2218 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2219 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2220 cifs_stats_inc(&tcon->num_symlinks);
2221 if (rc) {
2222 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
2223 }
2224
2225 if (pSMB)
2226 cifs_buf_release(pSMB);
2227
2228 if (rc == -EAGAIN)
2229 goto createSymLinkRetry;
2230
2231 return rc;
2232 }
2233
2234 int
2235 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2236 const char *fromName, const char *toName,
2237 const struct nls_table *nls_codepage, int remap)
2238 {
2239 TRANSACTION2_SPI_REQ *pSMB = NULL;
2240 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2241 char *data_offset;
2242 int name_len;
2243 int name_len_target;
2244 int rc = 0;
2245 int bytes_returned = 0;
2246 __u16 params, param_offset, offset, byte_count;
2247
2248 cFYI(1, ("In Create Hard link Unix style"));
2249 createHardLinkRetry:
2250 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2251 (void **) &pSMBr);
2252 if (rc)
2253 return rc;
2254
2255 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2256 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
2257 PATH_MAX, nls_codepage, remap);
2258 name_len++; /* trailing null */
2259 name_len *= 2;
2260
2261 } else { /* BB improve the check for buffer overruns BB */
2262 name_len = strnlen(toName, PATH_MAX);
2263 name_len++; /* trailing null */
2264 strncpy(pSMB->FileName, toName, name_len);
2265 }
2266 params = 6 + name_len;
2267 pSMB->MaxSetupCount = 0;
2268 pSMB->Reserved = 0;
2269 pSMB->Flags = 0;
2270 pSMB->Timeout = 0;
2271 pSMB->Reserved2 = 0;
2272 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2273 InformationLevel) - 4;
2274 offset = param_offset + params;
2275
2276 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2277 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2278 name_len_target =
2279 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
2280 nls_codepage, remap);
2281 name_len_target++; /* trailing null */
2282 name_len_target *= 2;
2283 } else { /* BB improve the check for buffer overruns BB */
2284 name_len_target = strnlen(fromName, PATH_MAX);
2285 name_len_target++; /* trailing null */
2286 strncpy(data_offset, fromName, name_len_target);
2287 }
2288
2289 pSMB->MaxParameterCount = cpu_to_le16(2);
2290 /* BB find exact max on data count below from sess*/
2291 pSMB->MaxDataCount = cpu_to_le16(1000);
2292 pSMB->SetupCount = 1;
2293 pSMB->Reserved3 = 0;
2294 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2295 byte_count = 3 /* pad */ + params + name_len_target;
2296 pSMB->ParameterCount = cpu_to_le16(params);
2297 pSMB->TotalParameterCount = pSMB->ParameterCount;
2298 pSMB->DataCount = cpu_to_le16(name_len_target);
2299 pSMB->TotalDataCount = pSMB->DataCount;
2300 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2301 pSMB->DataOffset = cpu_to_le16(offset);
2302 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2303 pSMB->Reserved4 = 0;
2304 pSMB->hdr.smb_buf_length += byte_count;
2305 pSMB->ByteCount = cpu_to_le16(byte_count);
2306 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2307 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2308 cifs_stats_inc(&tcon->num_hardlinks);
2309 if (rc) {
2310 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
2311 }
2312
2313 cifs_buf_release(pSMB);
2314 if (rc == -EAGAIN)
2315 goto createHardLinkRetry;
2316
2317 return rc;
2318 }
2319
2320 int
2321 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2322 const char *fromName, const char *toName,
2323 const struct nls_table *nls_codepage, int remap)
2324 {
2325 int rc = 0;
2326 NT_RENAME_REQ *pSMB = NULL;
2327 RENAME_RSP *pSMBr = NULL;
2328 int bytes_returned;
2329 int name_len, name_len2;
2330 __u16 count;
2331
2332 cFYI(1, ("In CIFSCreateHardLink"));
2333 winCreateHardLinkRetry:
2334
2335 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2336 (void **) &pSMBr);
2337 if (rc)
2338 return rc;
2339
2340 pSMB->SearchAttributes =
2341 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2342 ATTR_DIRECTORY);
2343 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2344 pSMB->ClusterCount = 0;
2345
2346 pSMB->BufferFormat = 0x04;
2347
2348 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2349 name_len =
2350 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
2351 PATH_MAX, nls_codepage, remap);
2352 name_len++; /* trailing null */
2353 name_len *= 2;
2354 pSMB->OldFileName[name_len] = 0; /* pad */
2355 pSMB->OldFileName[name_len + 1] = 0x04;
2356 name_len2 =
2357 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2358 toName, PATH_MAX, nls_codepage, remap);
2359 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2360 name_len2 *= 2; /* convert to bytes */
2361 } else { /* BB improve the check for buffer overruns BB */
2362 name_len = strnlen(fromName, PATH_MAX);
2363 name_len++; /* trailing null */
2364 strncpy(pSMB->OldFileName, fromName, name_len);
2365 name_len2 = strnlen(toName, PATH_MAX);
2366 name_len2++; /* trailing null */
2367 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2368 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2369 name_len2++; /* trailing null */
2370 name_len2++; /* signature byte */
2371 }
2372
2373 count = 1 /* string type byte */ + name_len + name_len2;
2374 pSMB->hdr.smb_buf_length += count;
2375 pSMB->ByteCount = cpu_to_le16(count);
2376
2377 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2378 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2379 cifs_stats_inc(&tcon->num_hardlinks);
2380 if (rc) {
2381 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
2382 }
2383 cifs_buf_release(pSMB);
2384 if (rc == -EAGAIN)
2385 goto winCreateHardLinkRetry;
2386
2387 return rc;
2388 }
2389
2390 int
2391 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
2392 const unsigned char *searchName,
2393 char *symlinkinfo, const int buflen,
2394 const struct nls_table *nls_codepage)
2395 {
2396 /* SMB_QUERY_FILE_UNIX_LINK */
2397 TRANSACTION2_QPI_REQ *pSMB = NULL;
2398 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2399 int rc = 0;
2400 int bytes_returned;
2401 int name_len;
2402 __u16 params, byte_count;
2403
2404 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
2405
2406 querySymLinkRetry:
2407 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2408 (void **) &pSMBr);
2409 if (rc)
2410 return rc;
2411
2412 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2413 name_len =
2414 cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
2415 PATH_MAX, nls_codepage);
2416 name_len++; /* trailing null */
2417 name_len *= 2;
2418 } else { /* BB improve the check for buffer overruns BB */
2419 name_len = strnlen(searchName, PATH_MAX);
2420 name_len++; /* trailing null */
2421 strncpy(pSMB->FileName, searchName, name_len);
2422 }
2423
2424 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2425 pSMB->TotalDataCount = 0;
2426 pSMB->MaxParameterCount = cpu_to_le16(2);
2427 /* BB find exact max data count below from sess structure BB */
2428 pSMB->MaxDataCount = cpu_to_le16(4000);
2429 pSMB->MaxSetupCount = 0;
2430 pSMB->Reserved = 0;
2431 pSMB->Flags = 0;
2432 pSMB->Timeout = 0;
2433 pSMB->Reserved2 = 0;
2434 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2435 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2436 pSMB->DataCount = 0;
2437 pSMB->DataOffset = 0;
2438 pSMB->SetupCount = 1;
2439 pSMB->Reserved3 = 0;
2440 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2441 byte_count = params + 1 /* pad */ ;
2442 pSMB->TotalParameterCount = cpu_to_le16(params);
2443 pSMB->ParameterCount = pSMB->TotalParameterCount;
2444 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2445 pSMB->Reserved4 = 0;
2446 pSMB->hdr.smb_buf_length += byte_count;
2447 pSMB->ByteCount = cpu_to_le16(byte_count);
2448
2449 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2450 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2451 if (rc) {
2452 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
2453 } else {
2454 /* decode response */
2455
2456 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2457 if (rc || (pSMBr->ByteCount < 2))
2458 /* BB also check enough total bytes returned */
2459 rc = -EIO; /* bad smb */
2460 else {
2461 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2462 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2463
2464 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2465 name_len = UniStrnlen((wchar_t *) ((char *)
2466 &pSMBr->hdr.Protocol + data_offset),
2467 min_t(const int, buflen, count) / 2);
2468 /* BB FIXME investigate remapping reserved chars here */
2469 cifs_strfromUCS_le(symlinkinfo,
2470 (__le16 *) ((char *)&pSMBr->hdr.Protocol
2471 + data_offset),
2472 name_len, nls_codepage);
2473 } else {
2474 strncpy(symlinkinfo,
2475 (char *) &pSMBr->hdr.Protocol +
2476 data_offset,
2477 min_t(const int, buflen, count));
2478 }
2479 symlinkinfo[buflen] = 0;
2480 /* just in case so calling code does not go off the end of buffer */
2481 }
2482 }
2483 cifs_buf_release(pSMB);
2484 if (rc == -EAGAIN)
2485 goto querySymLinkRetry;
2486 return rc;
2487 }
2488
2489 /* Initialize NT TRANSACT SMB into small smb request buffer.
2490 This assumes that all NT TRANSACTS that we init here have
2491 total parm and data under about 400 bytes (to fit in small cifs
2492 buffer size), which is the case so far, it easily fits. NB:
2493 Setup words themselves and ByteCount
2494 MaxSetupCount (size of returned setup area) and
2495 MaxParameterCount (returned parms size) must be set by caller */
2496 static int
2497 smb_init_ntransact(const __u16 sub_command, const int setup_count,
2498 const int parm_len, struct cifsTconInfo *tcon,
2499 void **ret_buf)
2500 {
2501 int rc;
2502 __u32 temp_offset;
2503 struct smb_com_ntransact_req *pSMB;
2504
2505 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
2506 (void **)&pSMB);
2507 if (rc)
2508 return rc;
2509 *ret_buf = (void *)pSMB;
2510 pSMB->Reserved = 0;
2511 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
2512 pSMB->TotalDataCount = 0;
2513 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2514 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2515 pSMB->ParameterCount = pSMB->TotalParameterCount;
2516 pSMB->DataCount = pSMB->TotalDataCount;
2517 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
2518 (setup_count * 2) - 4 /* for rfc1001 length itself */;
2519 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
2520 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
2521 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
2522 pSMB->SubCommand = cpu_to_le16(sub_command);
2523 return 0;
2524 }
2525
2526 static int
2527 validate_ntransact(char *buf, char **ppparm, char **ppdata,
2528 int *pdatalen, int *pparmlen)
2529 {
2530 char *end_of_smb;
2531 __u32 data_count, data_offset, parm_count, parm_offset;
2532 struct smb_com_ntransact_rsp *pSMBr;
2533
2534 if (buf == NULL)
2535 return -EINVAL;
2536
2537 pSMBr = (struct smb_com_ntransact_rsp *)buf;
2538
2539 /* ByteCount was converted from little endian in SendReceive */
2540 end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2541 (char *)&pSMBr->ByteCount;
2542
2543 data_offset = le32_to_cpu(pSMBr->DataOffset);
2544 data_count = le32_to_cpu(pSMBr->DataCount);
2545 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2546 parm_count = le32_to_cpu(pSMBr->ParameterCount);
2547
2548 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2549 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2550
2551 /* should we also check that parm and data areas do not overlap? */
2552 if (*ppparm > end_of_smb) {
2553 cFYI(1, ("parms start after end of smb"));
2554 return -EINVAL;
2555 } else if (parm_count + *ppparm > end_of_smb) {
2556 cFYI(1, ("parm end after end of smb"));
2557 return -EINVAL;
2558 } else if (*ppdata > end_of_smb) {
2559 cFYI(1, ("data starts after end of smb"));
2560 return -EINVAL;
2561 } else if (data_count + *ppdata > end_of_smb) {
2562 cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
2563 *ppdata, data_count, (data_count + *ppdata),
2564 end_of_smb, pSMBr));
2565 return -EINVAL;
2566 } else if (parm_count + data_count > pSMBr->ByteCount) {
2567 cFYI(1, ("parm count and data count larger than SMB"));
2568 return -EINVAL;
2569 }
2570 return 0;
2571 }
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 /* BB fix up return info */ char *acl_inf, const int buflen,
3071 const int acl_type)
3072 {
3073 int rc = 0;
3074 int buf_type = 0;
3075 QUERY_SEC_DESC_REQ * pSMB;
3076 struct kvec iov[1];
3077
3078 cFYI(1, ("GetCifsACL"));
3079
3080 rc = smb_init_ntransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3081 8 /* parm len */, tcon, (void **) &pSMB);
3082 if (rc)
3083 return rc;
3084
3085 pSMB->MaxParameterCount = cpu_to_le32(4);
3086 /* BB TEST with big acls that might need to be e.g. larger than 16K */
3087 pSMB->MaxSetupCount = 0;
3088 pSMB->Fid = fid; /* file handle always le */
3089 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3090 CIFS_ACL_DACL);
3091 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3092 pSMB->hdr.smb_buf_length += 11;
3093 iov[0].iov_base = (char *)pSMB;
3094 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
3095
3096 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3097 0 /* not long op */, 0 /* do not log STATUS codes */ );
3098 cifs_stats_inc(&tcon->num_acl_get);
3099 if (rc) {
3100 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
3101 } else { /* decode response */
3102 struct cifs_ntsd *psec_desc;
3103 __le32 * parm;
3104 int parm_len;
3105 int data_len;
3106 int acl_len;
3107 struct smb_com_ntransact_rsp *pSMBr;
3108
3109 /* validate_nttransact */
3110 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3111 (char **)&psec_desc,
3112 &parm_len, &data_len);
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, psec_desc));
3118
3119 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3120 rc = -EIO; /* bad smb */
3121 goto qsec_out;
3122 }
3123
3124 /* BB check that data area is minimum length and as big as acl_len */
3125
3126 acl_len = le32_to_cpu(*parm);
3127 /* BB check if (acl_len > bufsize) */
3128
3129 parse_sec_desc(psec_desc, acl_len);
3130 }
3131 qsec_out:
3132 if (buf_type == CIFS_SMALL_BUFFER)
3133 cifs_small_buf_release(iov[0].iov_base);
3134 else if (buf_type == CIFS_LARGE_BUFFER)
3135 cifs_buf_release(iov[0].iov_base);
3136 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3137 return rc;
3138 }
3139 #endif /* CONFIG_CIFS_EXPERIMENTAL */
3140
3141 /* Legacy Query Path Information call for lookup to old servers such
3142 as Win9x/WinME */
3143 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
3144 const unsigned char *searchName,
3145 FILE_ALL_INFO *pFinfo,
3146 const struct nls_table *nls_codepage, int remap)
3147 {
3148 QUERY_INFORMATION_REQ * pSMB;
3149 QUERY_INFORMATION_RSP * pSMBr;
3150 int rc = 0;
3151 int bytes_returned;
3152 int name_len;
3153
3154 cFYI(1, ("In SMBQPath path %s", searchName));
3155 QInfRetry:
3156 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3157 (void **) &pSMBr);
3158 if (rc)
3159 return rc;
3160
3161 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3162 name_len =
3163 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3164 PATH_MAX, nls_codepage, remap);
3165 name_len++; /* trailing null */
3166 name_len *= 2;
3167 } else {
3168 name_len = strnlen(searchName, PATH_MAX);
3169 name_len++; /* trailing null */
3170 strncpy(pSMB->FileName, searchName, name_len);
3171 }
3172 pSMB->BufferFormat = 0x04;
3173 name_len++; /* account for buffer type byte */
3174 pSMB->hdr.smb_buf_length += (__u16) name_len;
3175 pSMB->ByteCount = cpu_to_le16(name_len);
3176
3177 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3178 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3179 if (rc) {
3180 cFYI(1, ("Send error in QueryInfo = %d", rc));
3181 } else if (pFinfo) { /* decode response */
3182 struct timespec ts;
3183 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3184 /* BB FIXME - add time zone adjustment BB */
3185 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
3186 ts.tv_nsec = 0;
3187 ts.tv_sec = time;
3188 /* decode time fields */
3189 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3190 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3191 pFinfo->LastAccessTime = 0;
3192 pFinfo->AllocationSize =
3193 cpu_to_le64(le32_to_cpu(pSMBr->size));
3194 pFinfo->EndOfFile = pFinfo->AllocationSize;
3195 pFinfo->Attributes =
3196 cpu_to_le32(le16_to_cpu(pSMBr->attr));
3197 } else
3198 rc = -EIO; /* bad buffer passed in */
3199
3200 cifs_buf_release(pSMB);
3201
3202 if (rc == -EAGAIN)
3203 goto QInfRetry;
3204
3205 return rc;
3206 }
3207
3208
3209
3210
3211 int
3212 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
3213 const unsigned char *searchName,
3214 FILE_ALL_INFO * pFindData,
3215 int legacy /* old style infolevel */,
3216 const struct nls_table *nls_codepage, int remap)
3217 {
3218 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3219 TRANSACTION2_QPI_REQ *pSMB = NULL;
3220 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3221 int rc = 0;
3222 int bytes_returned;
3223 int name_len;
3224 __u16 params, byte_count;
3225
3226 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
3227 QPathInfoRetry:
3228 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3229 (void **) &pSMBr);
3230 if (rc)
3231 return rc;
3232
3233 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3234 name_len =
3235 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3236 PATH_MAX, nls_codepage, remap);
3237 name_len++; /* trailing null */
3238 name_len *= 2;
3239 } else { /* BB improve the check for buffer overruns BB */
3240 name_len = strnlen(searchName, PATH_MAX);
3241 name_len++; /* trailing null */
3242 strncpy(pSMB->FileName, searchName, name_len);
3243 }
3244
3245 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3246 pSMB->TotalDataCount = 0;
3247 pSMB->MaxParameterCount = cpu_to_le16(2);
3248 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3249 pSMB->MaxSetupCount = 0;
3250 pSMB->Reserved = 0;
3251 pSMB->Flags = 0;
3252 pSMB->Timeout = 0;
3253 pSMB->Reserved2 = 0;
3254 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3255 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3256 pSMB->DataCount = 0;
3257 pSMB->DataOffset = 0;
3258 pSMB->SetupCount = 1;
3259 pSMB->Reserved3 = 0;
3260 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3261 byte_count = params + 1 /* pad */ ;
3262 pSMB->TotalParameterCount = cpu_to_le16(params);
3263 pSMB->ParameterCount = pSMB->TotalParameterCount;
3264 if (legacy)
3265 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3266 else
3267 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3268 pSMB->Reserved4 = 0;
3269 pSMB->hdr.smb_buf_length += byte_count;
3270 pSMB->ByteCount = cpu_to_le16(byte_count);
3271
3272 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3273 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3274 if (rc) {
3275 cFYI(1, ("Send error in QPathInfo = %d", rc));
3276 } else { /* decode response */
3277 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3278
3279 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3280 rc = -EIO;
3281 else if (!legacy && (pSMBr->ByteCount < 40))
3282 rc = -EIO; /* bad smb */
3283 else if (legacy && (pSMBr->ByteCount < 24))
3284 rc = -EIO; /* 24 or 26 expected but we do not read
3285 last field */
3286 else if (pFindData) {
3287 int size;
3288 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3289 if (legacy) /* we do not read the last field, EAsize,
3290 fortunately since it varies by subdialect
3291 and on Set vs. Get, is two bytes or 4
3292 bytes depending but we don't care here */
3293 size = sizeof(FILE_INFO_STANDARD);
3294 else
3295 size = sizeof(FILE_ALL_INFO);
3296 memcpy((char *) pFindData,
3297 (char *) &pSMBr->hdr.Protocol +
3298 data_offset, size);
3299 } else
3300 rc = -ENOMEM;
3301 }
3302 cifs_buf_release(pSMB);
3303 if (rc == -EAGAIN)
3304 goto QPathInfoRetry;
3305
3306 return rc;
3307 }
3308
3309 int
3310 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
3311 const unsigned char *searchName,
3312 FILE_UNIX_BASIC_INFO * pFindData,
3313 const struct nls_table *nls_codepage, int remap)
3314 {
3315 /* SMB_QUERY_FILE_UNIX_BASIC */
3316 TRANSACTION2_QPI_REQ *pSMB = NULL;
3317 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3318 int rc = 0;
3319 int bytes_returned = 0;
3320 int name_len;
3321 __u16 params, byte_count;
3322
3323 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
3324 UnixQPathInfoRetry:
3325 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3326 (void **) &pSMBr);
3327 if (rc)
3328 return rc;
3329
3330 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3331 name_len =
3332 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3333 PATH_MAX, nls_codepage, remap);
3334 name_len++; /* trailing null */
3335 name_len *= 2;
3336 } else { /* BB improve the check for buffer overruns BB */
3337 name_len = strnlen(searchName, PATH_MAX);
3338 name_len++; /* trailing null */
3339 strncpy(pSMB->FileName, searchName, name_len);
3340 }
3341
3342 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3343 pSMB->TotalDataCount = 0;
3344 pSMB->MaxParameterCount = cpu_to_le16(2);
3345 /* BB find exact max SMB PDU from sess structure BB */
3346 pSMB->MaxDataCount = cpu_to_le16(4000);
3347 pSMB->MaxSetupCount = 0;
3348 pSMB->Reserved = 0;
3349 pSMB->Flags = 0;
3350 pSMB->Timeout = 0;
3351 pSMB->Reserved2 = 0;
3352 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3353 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3354 pSMB->DataCount = 0;
3355 pSMB->DataOffset = 0;
3356 pSMB->SetupCount = 1;
3357 pSMB->Reserved3 = 0;
3358 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3359 byte_count = params + 1 /* pad */ ;
3360 pSMB->TotalParameterCount = cpu_to_le16(params);
3361 pSMB->ParameterCount = pSMB->TotalParameterCount;
3362 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3363 pSMB->Reserved4 = 0;
3364 pSMB->hdr.smb_buf_length += byte_count;
3365 pSMB->ByteCount = cpu_to_le16(byte_count);
3366
3367 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3368 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3369 if (rc) {
3370 cFYI(1, ("Send error in QPathInfo = %d", rc));
3371 } else { /* decode response */
3372 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3373
3374 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
3375 cERROR(1, ("Malformed FILE_UNIX_BASIC_INFO response.\n"
3376 "Unix Extensions can be disabled on mount "
3377 "by specifying the nosfu mount option."));
3378 rc = -EIO; /* bad smb */
3379 } else {
3380 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3381 memcpy((char *) pFindData,
3382 (char *) &pSMBr->hdr.Protocol +
3383 data_offset,
3384 sizeof (FILE_UNIX_BASIC_INFO));
3385 }
3386 }
3387 cifs_buf_release(pSMB);
3388 if (rc == -EAGAIN)
3389 goto UnixQPathInfoRetry;
3390
3391 return rc;
3392 }
3393
3394 #if 0 /* function unused at present */
3395 int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
3396 const char *searchName, FILE_ALL_INFO * findData,
3397 const struct nls_table *nls_codepage)
3398 {
3399 /* level 257 SMB_ */
3400 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3401 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3402 int rc = 0;
3403 int bytes_returned;
3404 int name_len;
3405 __u16 params, byte_count;
3406
3407 cFYI(1, ("In FindUnique"));
3408 findUniqueRetry:
3409 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3410 (void **) &pSMBr);
3411 if (rc)
3412 return rc;
3413
3414 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3415 name_len =
3416 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3417 PATH_MAX, nls_codepage);
3418 name_len++; /* trailing null */
3419 name_len *= 2;
3420 } else { /* BB improve the check for buffer overruns BB */
3421 name_len = strnlen(searchName, PATH_MAX);
3422 name_len++; /* trailing null */
3423 strncpy(pSMB->FileName, searchName, name_len);
3424 }
3425
3426 params = 12 + name_len /* includes null */ ;
3427 pSMB->TotalDataCount = 0; /* no EAs */
3428 pSMB->MaxParameterCount = cpu_to_le16(2);
3429 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3430 pSMB->MaxSetupCount = 0;
3431 pSMB->Reserved = 0;
3432 pSMB->Flags = 0;
3433 pSMB->Timeout = 0;
3434 pSMB->Reserved2 = 0;
3435 pSMB->ParameterOffset = cpu_to_le16(
3436 offsetof(struct smb_com_transaction2_ffirst_req, InformationLevel)-4);
3437 pSMB->DataCount = 0;
3438 pSMB->DataOffset = 0;
3439 pSMB->SetupCount = 1; /* one byte, no need to le convert */
3440 pSMB->Reserved3 = 0;
3441 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3442 byte_count = params + 1 /* pad */ ;
3443 pSMB->TotalParameterCount = cpu_to_le16(params);
3444 pSMB->ParameterCount = pSMB->TotalParameterCount;
3445 pSMB->SearchAttributes =
3446 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3447 ATTR_DIRECTORY);
3448 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
3449 pSMB->SearchFlags = cpu_to_le16(1);
3450 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
3451 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
3452 pSMB->hdr.smb_buf_length += byte_count;
3453 pSMB->ByteCount = cpu_to_le16(byte_count);
3454
3455 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3456 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3457
3458 if (rc) {
3459 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
3460 } else { /* decode response */
3461 cifs_stats_inc(&tcon->num_ffirst);
3462 /* BB fill in */
3463 }
3464
3465 cifs_buf_release(pSMB);
3466 if (rc == -EAGAIN)
3467 goto findUniqueRetry;
3468
3469 return rc;
3470 }
3471 #endif /* end unused (temporarily) function */
3472
3473 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3474 int
3475 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
3476 const char *searchName,
3477 const struct nls_table *nls_codepage,
3478 __u16 *pnetfid,
3479 struct cifs_search_info *psrch_inf, int remap, const char dirsep)
3480 {
3481 /* level 257 SMB_ */
3482 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3483 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3484 T2_FFIRST_RSP_PARMS * parms;
3485 int rc = 0;
3486 int bytes_returned = 0;
3487 int name_len;
3488 __u16 params, byte_count;
3489
3490 cFYI(1, ("In FindFirst for %s", searchName));
3491
3492 findFirstRetry:
3493 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3494 (void **) &pSMBr);
3495 if (rc)
3496 return rc;
3497
3498 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3499 name_len =
3500 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3501 PATH_MAX, nls_codepage, remap);
3502 /* We can not add the asterik earlier in case
3503 it got remapped to 0xF03A as if it were part of the
3504 directory name instead of a wildcard */
3505 name_len *= 2;
3506 pSMB->FileName[name_len] = dirsep;
3507 pSMB->FileName[name_len+1] = 0;
3508 pSMB->FileName[name_len+2] = '*';
3509 pSMB->FileName[name_len+3] = 0;
3510 name_len += 4; /* now the trailing null */
3511 pSMB->FileName[name_len] = 0; /* null terminate just in case */
3512 pSMB->FileName[name_len+1] = 0;
3513 name_len += 2;
3514 } else { /* BB add check for overrun of SMB buf BB */
3515 name_len = strnlen(searchName, PATH_MAX);
3516 /* BB fix here and in unicode clause above ie
3517 if (name_len > buffersize-header)
3518 free buffer exit; BB */
3519 strncpy(pSMB->FileName, searchName, name_len);
3520 pSMB->FileName[name_len] = dirsep;
3521 pSMB->FileName[name_len+1] = '*';
3522 pSMB->FileName[name_len+2] = 0;
3523 name_len += 3;
3524 }
3525
3526 params = 12 + name_len /* includes null */ ;
3527 pSMB->TotalDataCount = 0; /* no EAs */
3528 pSMB->MaxParameterCount = cpu_to_le16(10);
3529 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
3530 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3531 pSMB->MaxSetupCount = 0;
3532 pSMB->Reserved = 0;
3533 pSMB->Flags = 0;
3534 pSMB->Timeout = 0;
3535 pSMB->Reserved2 = 0;
3536 byte_count = params + 1 /* pad */ ;
3537 pSMB->TotalParameterCount = cpu_to_le16(params);
3538 pSMB->ParameterCount = pSMB->TotalParameterCount;
3539 pSMB->ParameterOffset = cpu_to_le16(
3540 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3541 - 4);
3542 pSMB->DataCount = 0;
3543 pSMB->DataOffset = 0;
3544 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
3545 pSMB->Reserved3 = 0;
3546 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3547 pSMB->SearchAttributes =
3548 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3549 ATTR_DIRECTORY);
3550 pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3551 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
3552 CIFS_SEARCH_RETURN_RESUME);
3553 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3554
3555 /* BB what should we set StorageType to? Does it matter? BB */
3556 pSMB->SearchStorageType = 0;
3557 pSMB->hdr.smb_buf_length += byte_count;
3558 pSMB->ByteCount = cpu_to_le16(byte_count);
3559
3560 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3561 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3562 cifs_stats_inc(&tcon->num_ffirst);
3563
3564 if (rc) {/* BB add logic to retry regular search if Unix search
3565 rejected unexpectedly by server */
3566 /* BB Add code to handle unsupported level rc */
3567 cFYI(1, ("Error in FindFirst = %d", rc));
3568
3569 cifs_buf_release(pSMB);
3570
3571 /* BB eventually could optimize out free and realloc of buf */
3572 /* for this case */
3573 if (rc == -EAGAIN)
3574 goto findFirstRetry;
3575 } else { /* decode response */
3576 /* BB remember to free buffer if error BB */
3577 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3578 if (rc == 0) {
3579 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3580 psrch_inf->unicode = TRUE;
3581 else
3582 psrch_inf->unicode = FALSE;
3583
3584 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3585 psrch_inf->smallBuf = 0;
3586 psrch_inf->srch_entries_start =
3587 (char *) &pSMBr->hdr.Protocol +
3588 le16_to_cpu(pSMBr->t2.DataOffset);
3589 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3590 le16_to_cpu(pSMBr->t2.ParameterOffset));
3591
3592 if (parms->EndofSearch)
3593 psrch_inf->endOfSearch = TRUE;
3594 else
3595 psrch_inf->endOfSearch = FALSE;
3596
3597 psrch_inf->entries_in_buffer =
3598 le16_to_cpu(parms->SearchCount);
3599 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
3600 psrch_inf->entries_in_buffer;
3601 *pnetfid = parms->SearchHandle;
3602 } else {
3603 cifs_buf_release(pSMB);
3604 }
3605 }
3606
3607 return rc;
3608 }
3609
3610 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3611 __u16 searchHandle, struct cifs_search_info *psrch_inf)
3612 {
3613 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3614 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3615 T2_FNEXT_RSP_PARMS * parms;
3616 char *response_data;
3617 int rc = 0;
3618 int bytes_returned, name_len;
3619 __u16 params, byte_count;
3620
3621 cFYI(1, ("In FindNext"));
3622
3623 if (psrch_inf->endOfSearch == TRUE)
3624 return -ENOENT;
3625
3626 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3627 (void **) &pSMBr);
3628 if (rc)
3629 return rc;
3630
3631 params = 14; /* includes 2 bytes of null string, converted to LE below*/
3632 byte_count = 0;
3633 pSMB->TotalDataCount = 0; /* no EAs */
3634 pSMB->MaxParameterCount = cpu_to_le16(8);
3635 pSMB->MaxDataCount =
3636 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
3637 0xFFFFFF00);
3638 pSMB->MaxSetupCount = 0;
3639 pSMB->Reserved = 0;
3640 pSMB->Flags = 0;
3641 pSMB->Timeout = 0;
3642 pSMB->Reserved2 = 0;
3643 pSMB->ParameterOffset = cpu_to_le16(
3644 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3645 pSMB->DataCount = 0;
3646 pSMB->DataOffset = 0;
3647 pSMB->SetupCount = 1;
3648 pSMB->Reserved3 = 0;
3649 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3650 pSMB->SearchHandle = searchHandle; /* always kept as le */
3651 pSMB->SearchCount =
3652 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
3653 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3654 pSMB->ResumeKey = psrch_inf->resume_key;
3655 pSMB->SearchFlags =
3656 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3657
3658 name_len = psrch_inf->resume_name_len;
3659 params += name_len;
3660 if (name_len < PATH_MAX) {
3661 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3662 byte_count += name_len;
3663 /* 14 byte parm len above enough for 2 byte null terminator */
3664 pSMB->ResumeFileName[name_len] = 0;
3665 pSMB->ResumeFileName[name_len+1] = 0;
3666 } else {
3667 rc = -EINVAL;
3668 goto FNext2_err_exit;
3669 }
3670 byte_count = params + 1 /* pad */ ;
3671 pSMB->TotalParameterCount = cpu_to_le16(params);
3672 pSMB->ParameterCount = pSMB->TotalParameterCount;
3673 pSMB->hdr.smb_buf_length += byte_count;
3674 pSMB->ByteCount = cpu_to_le16(byte_count);
3675
3676 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3677 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3678 cifs_stats_inc(&tcon->num_fnext);
3679 if (rc) {
3680 if (rc == -EBADF) {
3681 psrch_inf->endOfSearch = TRUE;
3682 rc = 0; /* search probably was closed at end of search*/
3683 } else
3684 cFYI(1, ("FindNext returned = %d", rc));
3685 } else { /* decode response */
3686 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3687
3688 if (rc == 0) {
3689 /* BB fixme add lock for file (srch_info) struct here */
3690 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3691 psrch_inf->unicode = TRUE;
3692 else
3693 psrch_inf->unicode = FALSE;
3694 response_data = (char *) &pSMBr->hdr.Protocol +
3695 le16_to_cpu(pSMBr->t2.ParameterOffset);
3696 parms = (T2_FNEXT_RSP_PARMS *)response_data;
3697 response_data = (char *)&pSMBr->hdr.Protocol +
3698 le16_to_cpu(pSMBr->t2.DataOffset);
3699 if (psrch_inf->smallBuf)
3700 cifs_small_buf_release(
3701 psrch_inf->ntwrk_buf_start);
3702 else
3703 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3704 psrch_inf->srch_entries_start = response_data;
3705 psrch_inf->ntwrk_buf_start = (char *)pSMB;
3706 psrch_inf->smallBuf = 0;
3707 if (parms->EndofSearch)
3708 psrch_inf->endOfSearch = TRUE;
3709 else
3710 psrch_inf->endOfSearch = FALSE;
3711 psrch_inf->entries_in_buffer =
3712 le16_to_cpu(parms->SearchCount);
3713 psrch_inf->index_of_last_entry +=
3714 psrch_inf->entries_in_buffer;
3715 /* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",
3716 psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry)); */
3717
3718 /* BB fixme add unlock here */
3719 }
3720
3721 }
3722
3723 /* BB On error, should we leave previous search buf (and count and
3724 last entry fields) intact or free the previous one? */
3725
3726 /* Note: On -EAGAIN error only caller can retry on handle based calls
3727 since file handle passed in no longer valid */
3728 FNext2_err_exit:
3729 if (rc != 0)
3730 cifs_buf_release(pSMB);
3731 return rc;
3732 }
3733
3734 int
3735 CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
3736 const __u16 searchHandle)
3737 {
3738 int rc = 0;
3739 FINDCLOSE_REQ *pSMB = NULL;
3740 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
3741 int bytes_returned;
3742
3743 cFYI(1, ("In CIFSSMBFindClose"));
3744 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3745
3746 /* no sense returning error if session restarted
3747 as file handle has been closed */
3748 if (rc == -EAGAIN)
3749 return 0;
3750 if (rc)
3751 return rc;
3752
3753 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
3754 pSMB->FileID = searchHandle;
3755 pSMB->ByteCount = 0;
3756 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3757 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3758 if (rc) {
3759 cERROR(1, ("Send error in FindClose = %d", rc));
3760 }
3761 cifs_stats_inc(&tcon->num_fclose);
3762 cifs_small_buf_release(pSMB);
3763
3764 /* Since session is dead, search handle closed on server already */
3765 if (rc == -EAGAIN)
3766 rc = 0;
3767
3768 return rc;
3769 }
3770
3771 int
3772 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3773 const unsigned char *searchName,
3774 __u64 * inode_number,
3775 const struct nls_table *nls_codepage, int remap)
3776 {
3777 int rc = 0;
3778 TRANSACTION2_QPI_REQ *pSMB = NULL;
3779 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3780 int name_len, bytes_returned;
3781 __u16 params, byte_count;
3782
3783 cFYI(1, ("In GetSrvInodeNum for %s", searchName));
3784 if (tcon == NULL)
3785 return -ENODEV;
3786
3787 GetInodeNumberRetry:
3788 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3789 (void **) &pSMBr);
3790 if (rc)
3791 return rc;
3792
3793 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3794 name_len =
3795 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3796 PATH_MAX, nls_codepage, remap);
3797 name_len++; /* trailing null */
3798 name_len *= 2;
3799 } else { /* BB improve the check for buffer overruns BB */
3800 name_len = strnlen(searchName, PATH_MAX);
3801 name_len++; /* trailing null */
3802 strncpy(pSMB->FileName, searchName, name_len);
3803 }
3804
3805 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3806 pSMB->TotalDataCount = 0;
3807 pSMB->MaxParameterCount = cpu_to_le16(2);
3808 /* BB find exact max data count below from sess structure BB */
3809 pSMB->MaxDataCount = cpu_to_le16(4000);
3810 pSMB->MaxSetupCount = 0;
3811 pSMB->Reserved = 0;
3812 pSMB->Flags = 0;
3813 pSMB->Timeout = 0;
3814 pSMB->Reserved2 = 0;
3815 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3816 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3817 pSMB->DataCount = 0;
3818 pSMB->DataOffset = 0;
3819 pSMB->SetupCount = 1;
3820 pSMB->Reserved3 = 0;
3821 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3822 byte_count = params + 1 /* pad */ ;
3823 pSMB->TotalParameterCount = cpu_to_le16(params);
3824 pSMB->ParameterCount = pSMB->TotalParameterCount;
3825 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3826 pSMB->Reserved4 = 0;
3827 pSMB->hdr.smb_buf_length += byte_count;
3828 pSMB->ByteCount = cpu_to_le16(byte_count);
3829
3830 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3831 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3832 if (rc) {
3833 cFYI(1, ("error %d in QueryInternalInfo", rc));
3834 } else {
3835 /* decode response */
3836 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3837 if (rc || (pSMBr->ByteCount < 2))
3838 /* BB also check enough total bytes returned */
3839 /* If rc should we check for EOPNOSUPP and
3840 disable the srvino flag? or in caller? */
3841 rc = -EIO; /* bad smb */
3842 else {
3843 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3844 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3845 struct file_internal_info *pfinfo;
3846 /* BB Do we need a cast or hash here ? */
3847 if (count < 8) {
3848 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3849 rc = -EIO;
3850 goto GetInodeNumOut;
3851 }
3852 pfinfo = (struct file_internal_info *)
3853 (data_offset + (char *) &pSMBr->hdr.Protocol);
3854 *inode_number = pfinfo->UniqueId;
3855 }
3856 }
3857 GetInodeNumOut:
3858 cifs_buf_release(pSMB);
3859 if (rc == -EAGAIN)
3860 goto GetInodeNumberRetry;
3861 return rc;
3862 }
3863
3864 int
3865 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3866 const unsigned char *searchName,
3867 unsigned char **targetUNCs,
3868 unsigned int *number_of_UNC_in_array,
3869 const struct nls_table *nls_codepage, int remap)
3870 {
3871 /* TRANS2_GET_DFS_REFERRAL */
3872 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
3873 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
3874 struct dfs_referral_level_3 *referrals = NULL;
3875 int rc = 0;
3876 int bytes_returned;
3877 int name_len;
3878 unsigned int i;
3879 char *temp;
3880 __u16 params, byte_count;
3881 *number_of_UNC_in_array = 0;
3882 *targetUNCs = NULL;
3883
3884 cFYI(1, ("In GetDFSRefer the path %s", searchName));
3885 if (ses == NULL)
3886 return -ENODEV;
3887 getDFSRetry:
3888 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
3889 (void **) &pSMBr);
3890 if (rc)
3891 return rc;
3892
3893 /* server pointer checked in called function,
3894 but should never be null here anyway */
3895 pSMB->hdr.Mid = GetNextMid(ses->server);
3896 pSMB->hdr.Tid = ses->ipc_tid;
3897 pSMB->hdr.Uid = ses->Suid;
3898 if (ses->capabilities & CAP_STATUS32)
3899 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
3900 if (ses->capabilities & CAP_DFS)
3901 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
3902
3903 if (ses->capabilities & CAP_UNICODE) {
3904 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
3905 name_len =
3906 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
3907 searchName, PATH_MAX, nls_codepage, remap);
3908 name_len++; /* trailing null */
3909 name_len *= 2;
3910 } else { /* BB improve the check for buffer overruns BB */
3911 name_len = strnlen(searchName, PATH_MAX);
3912 name_len++; /* trailing null */
3913 strncpy(pSMB->RequestFileName, searchName, name_len);
3914 }
3915
3916 if (ses->server) {
3917 if (ses->server->secMode &
3918 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3919 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3920 }
3921
3922 pSMB->hdr.Uid = ses->Suid;
3923
3924 params = 2 /* level */ + name_len /*includes null */ ;
3925 pSMB->TotalDataCount = 0;
3926 pSMB->DataCount = 0;
3927 pSMB->DataOffset = 0;
3928 pSMB->MaxParameterCount = 0;
3929 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3930 pSMB->MaxSetupCount = 0;
3931 pSMB->Reserved = 0;
3932 pSMB->Flags = 0;
3933 pSMB->Timeout = 0;
3934 pSMB->Reserved2 = 0;
3935 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3936 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
3937 pSMB->SetupCount = 1;
3938 pSMB->Reserved3 = 0;
3939 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
3940 byte_count = params + 3 /* pad */ ;
3941 pSMB->ParameterCount = cpu_to_le16(params);
3942 pSMB->TotalParameterCount = pSMB->ParameterCount;
3943 pSMB->MaxReferralLevel = cpu_to_le16(3);
3944 pSMB->hdr.smb_buf_length += byte_count;
3945 pSMB->ByteCount = cpu_to_le16(byte_count);
3946
3947 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
3948 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3949 if (rc) {
3950 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
3951 } else { /* decode response */
3952 /* BB Add logic to parse referrals here */
3953 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3954
3955 /* BB Also check if enough total bytes returned? */
3956 if (rc || (pSMBr->ByteCount < 17))
3957 rc = -EIO; /* bad smb */
3958 else {
3959 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3960 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
3961
3962 cFYI(1,
3963 ("Decoding GetDFSRefer response BCC: %d Offset %d",
3964 pSMBr->ByteCount, data_offset));
3965 referrals =
3966 (struct dfs_referral_level_3 *)
3967 (8 /* sizeof start of data block */ +
3968 data_offset +
3969 (char *) &pSMBr->hdr.Protocol);
3970 cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n"
3971 "for referral one refer size: 0x%x srv "
3972 "type: 0x%x refer flags: 0x%x ttl: 0x%x",
3973 le16_to_cpu(pSMBr->NumberOfReferrals),
3974 le16_to_cpu(pSMBr->DFSFlags),
3975 le16_to_cpu(referrals->ReferralSize),
3976 le16_to_cpu(referrals->ServerType),
3977 le16_to_cpu(referrals->ReferralFlags),
3978 le16_to_cpu(referrals->TimeToLive)));
3979 /* BB This field is actually two bytes in from start of
3980 data block so we could do safety check that DataBlock
3981 begins at address of pSMBr->NumberOfReferrals */
3982 *number_of_UNC_in_array =
3983 le16_to_cpu(pSMBr->NumberOfReferrals);
3984
3985 /* BB Fix below so can return more than one referral */
3986 if (*number_of_UNC_in_array > 1)
3987 *number_of_UNC_in_array = 1;
3988
3989 /* get the length of the strings describing refs */
3990 name_len = 0;
3991 for (i = 0; i < *number_of_UNC_in_array; i++) {
3992 /* make sure that DfsPathOffset not past end */
3993 __u16 offset =
3994 le16_to_cpu(referrals->DfsPathOffset);
3995 if (offset > data_count) {
3996 /* if invalid referral, stop here and do
3997 not try to copy any more */
3998 *number_of_UNC_in_array = i;
3999 break;
4000 }
4001 temp = ((char *)referrals) + offset;
4002
4003 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
4004 name_len += UniStrnlen((wchar_t *)temp,
4005 data_count);
4006 } else {
4007 name_len += strnlen(temp, data_count);
4008 }
4009 referrals++;
4010 /* BB add check that referral pointer does
4011 not fall off end PDU */
4012 }
4013 /* BB add check for name_len bigger than bcc */
4014 *targetUNCs =
4015 kmalloc(name_len+1+(*number_of_UNC_in_array),
4016 GFP_KERNEL);
4017 if (*targetUNCs == NULL) {
4018 rc = -ENOMEM;
4019 goto GetDFSRefExit;
4020 }
4021 /* copy the ref strings */
4022 referrals = (struct dfs_referral_level_3 *)
4023 (8 /* sizeof data hdr */ + data_offset +
4024 (char *) &pSMBr->hdr.Protocol);
4025
4026 for (i = 0; i < *number_of_UNC_in_array; i++) {
4027 temp = ((char *)referrals) +
4028 le16_to_cpu(referrals->DfsPathOffset);
4029 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
4030 cifs_strfromUCS_le(*targetUNCs,
4031 (__le16 *) temp,
4032 name_len,
4033 nls_codepage);
4034 } else {
4035 strncpy(*targetUNCs, temp, name_len);
4036 }
4037 /* BB update target_uncs pointers */
4038 referrals++;
4039 }
4040 temp = *targetUNCs;
4041 temp[name_len] = 0;
4042 }
4043
4044 }
4045 GetDFSRefExit:
4046 if (pSMB)
4047 cifs_buf_release(pSMB);
4048
4049 if (rc == -EAGAIN)
4050 goto getDFSRetry;
4051
4052 return rc;
4053 }
4054
4055 /* Query File System Info such as free space to old servers such as Win 9x */
4056 int
4057 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4058 {
4059 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4060 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4061 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4062 FILE_SYSTEM_ALLOC_INFO *response_data;
4063 int rc = 0;
4064 int bytes_returned = 0;
4065 __u16 params, byte_count;
4066
4067 cFYI(1, ("OldQFSInfo"));
4068 oldQFSInfoRetry:
4069 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4070 (void **) &pSMBr);
4071 if (rc)
4072 return rc;
4073
4074 params = 2; /* level */
4075 pSMB->TotalDataCount = 0;
4076 pSMB->MaxParameterCount = cpu_to_le16(2);
4077 pSMB->MaxDataCount = cpu_to_le16(1000);
4078 pSMB->MaxSetupCount = 0;
4079 pSMB->Reserved = 0;
4080 pSMB->Flags = 0;
4081 pSMB->Timeout = 0;
4082 pSMB->Reserved2 = 0;
4083 byte_count = params + 1 /* pad */ ;
4084 pSMB->TotalParameterCount = cpu_to_le16(params);
4085 pSMB->ParameterCount = pSMB->TotalParameterCount;
4086 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4087 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4088 pSMB->DataCount = 0;
4089 pSMB->DataOffset = 0;
4090 pSMB->SetupCount = 1;
4091 pSMB->Reserved3 = 0;
4092 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4093 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4094 pSMB->hdr.smb_buf_length += byte_count;
4095 pSMB->ByteCount = cpu_to_le16(byte_count);
4096
4097 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4098 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4099 if (rc) {
4100 cFYI(1, ("Send error in QFSInfo = %d", rc));
4101 } else { /* decode response */
4102 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4103
4104 if (rc || (pSMBr->ByteCount < 18))
4105 rc = -EIO; /* bad smb */
4106 else {
4107 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4108 cFYI(1, ("qfsinf resp BCC: %d Offset %d",
4109 pSMBr->ByteCount, data_offset));
4110
4111 response_data = (FILE_SYSTEM_ALLOC_INFO *)
4112 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4113 FSData->f_bsize =
4114 le16_to_cpu(response_data->BytesPerSector) *
4115 le32_to_cpu(response_data->
4116 SectorsPerAllocationUnit);
4117 FSData->f_blocks =
4118 le32_to_cpu(response_data->TotalAllocationUnits);
4119 FSData->f_bfree = FSData->f_bavail =
4120 le32_to_cpu(response_data->FreeAllocationUnits);
4121 cFYI(1,
4122 ("Blocks: %lld Free: %lld Block size %ld",
4123 (unsigned long long)FSData->f_blocks,
4124 (unsigned long long)FSData->f_bfree,
4125 FSData->f_bsize));
4126 }
4127 }
4128 cifs_buf_release(pSMB);
4129
4130 if (rc == -EAGAIN)
4131 goto oldQFSInfoRetry;
4132
4133 return rc;
4134 }
4135
4136 int
4137 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4138 {
4139 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4140 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4141 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4142 FILE_SYSTEM_INFO *response_data;
4143 int rc = 0;
4144 int bytes_returned = 0;
4145 __u16 params, byte_count;
4146
4147 cFYI(1, ("In QFSInfo"));
4148 QFSInfoRetry:
4149 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4150 (void **) &pSMBr);
4151 if (rc)
4152 return rc;
4153
4154 params = 2; /* level */
4155 pSMB->TotalDataCount = 0;
4156 pSMB->MaxParameterCount = cpu_to_le16(2);
4157 pSMB->MaxDataCount = cpu_to_le16(1000);
4158 pSMB->MaxSetupCount = 0;
4159 pSMB->Reserved = 0;
4160 pSMB->Flags = 0;
4161 pSMB->Timeout = 0;
4162 pSMB->Reserved2 = 0;
4163 byte_count = params + 1 /* pad */ ;
4164 pSMB->TotalParameterCount = cpu_to_le16(params);
4165 pSMB->ParameterCount = pSMB->TotalParameterCount;
4166 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4167 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4168 pSMB->DataCount = 0;
4169 pSMB->DataOffset = 0;
4170 pSMB->SetupCount = 1;
4171 pSMB->Reserved3 = 0;
4172 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4173 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4174 pSMB->hdr.smb_buf_length += byte_count;
4175 pSMB->ByteCount = cpu_to_le16(byte_count);
4176
4177 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4178 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4179 if (rc) {
4180 cFYI(1, ("Send error in QFSInfo = %d", rc));
4181 } else { /* decode response */
4182 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4183
4184 if (rc || (pSMBr->ByteCount < 24))
4185 rc = -EIO; /* bad smb */
4186 else {
4187 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4188
4189 response_data =
4190 (FILE_SYSTEM_INFO
4191 *) (((char *) &pSMBr->hdr.Protocol) +
4192 data_offset);
4193 FSData->f_bsize =
4194 le32_to_cpu(response_data->BytesPerSector) *
4195 le32_to_cpu(response_data->
4196 SectorsPerAllocationUnit);
4197 FSData->f_blocks =
4198 le64_to_cpu(response_data->TotalAllocationUnits);
4199 FSData->f_bfree = FSData->f_bavail =
4200 le64_to_cpu(response_data->FreeAllocationUnits);
4201 cFYI(1,
4202 ("Blocks: %lld Free: %lld Block size %ld",
4203 (unsigned long long)FSData->f_blocks,
4204 (unsigned long long)FSData->f_bfree,
4205 FSData->f_bsize));
4206 }
4207 }
4208 cifs_buf_release(pSMB);
4209
4210 if (rc == -EAGAIN)
4211 goto QFSInfoRetry;
4212
4213 return rc;
4214 }
4215
4216 int
4217 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
4218 {
4219 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
4220 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4221 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4222 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4223 int rc = 0;
4224 int bytes_returned = 0;
4225 __u16 params, byte_count;
4226
4227 cFYI(1, ("In QFSAttributeInfo"));
4228 QFSAttributeRetry:
4229 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4230 (void **) &pSMBr);
4231 if (rc)
4232 return rc;
4233
4234 params = 2; /* level */
4235 pSMB->TotalDataCount = 0;
4236 pSMB->MaxParameterCount = cpu_to_le16(2);
4237 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4238 pSMB->MaxSetupCount = 0;
4239 pSMB->Reserved = 0;
4240 pSMB->Flags = 0;
4241 pSMB->Timeout = 0;
4242 pSMB->Reserved2 = 0;
4243 byte_count = params + 1 /* pad */ ;
4244 pSMB->TotalParameterCount = cpu_to_le16(params);
4245 pSMB->ParameterCount = pSMB->TotalParameterCount;
4246 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4247 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4248 pSMB->DataCount = 0;
4249 pSMB->DataOffset = 0;
4250 pSMB->SetupCount = 1;
4251 pSMB->Reserved3 = 0;
4252 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4253 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4254 pSMB->hdr.smb_buf_length += byte_count;
4255 pSMB->ByteCount = cpu_to_le16(byte_count);
4256
4257 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4258 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4259 if (rc) {
4260 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
4261 } else { /* decode response */
4262 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4263
4264 if (rc || (pSMBr->ByteCount < 13)) {
4265 /* BB also check if enough bytes returned */
4266 rc = -EIO; /* bad smb */
4267 } else {
4268 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4269 response_data =
4270 (FILE_SYSTEM_ATTRIBUTE_INFO
4271 *) (((char *) &pSMBr->hdr.Protocol) +
4272 data_offset);
4273 memcpy(&tcon->fsAttrInfo, response_data,
4274 sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4275 }
4276 }
4277 cifs_buf_release(pSMB);
4278
4279 if (rc == -EAGAIN)
4280 goto QFSAttributeRetry;
4281
4282 return rc;
4283 }
4284
4285 int
4286 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
4287 {
4288 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4289 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4290 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4291 FILE_SYSTEM_DEVICE_INFO *response_data;
4292 int rc = 0;
4293 int bytes_returned = 0;
4294 __u16 params, byte_count;
4295
4296 cFYI(1, ("In QFSDeviceInfo"));
4297 QFSDeviceRetry:
4298 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4299 (void **) &pSMBr);
4300 if (rc)
4301 return rc;
4302
4303 params = 2; /* level */
4304 pSMB->TotalDataCount = 0;
4305 pSMB->MaxParameterCount = cpu_to_le16(2);
4306 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4307 pSMB->MaxSetupCount = 0;
4308 pSMB->Reserved = 0;
4309 pSMB->Flags = 0;
4310 pSMB->Timeout = 0;
4311 pSMB->Reserved2 = 0;
4312 byte_count = params + 1 /* pad */ ;
4313 pSMB->TotalParameterCount = cpu_to_le16(params);
4314 pSMB->ParameterCount = pSMB->TotalParameterCount;
4315 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4316 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4317
4318 pSMB->DataCount = 0;
4319 pSMB->DataOffset = 0;
4320 pSMB->SetupCount = 1;
4321 pSMB->Reserved3 = 0;
4322 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4323 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4324 pSMB->hdr.smb_buf_length += byte_count;
4325 pSMB->ByteCount = cpu_to_le16(byte_count);
4326
4327 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4328 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4329 if (rc) {
4330 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
4331 } else { /* decode response */
4332 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4333
4334 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
4335 rc = -EIO; /* bad smb */
4336 else {
4337 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4338 response_data =
4339 (FILE_SYSTEM_DEVICE_INFO *)
4340 (((char *) &pSMBr->hdr.Protocol) +
4341 data_offset);
4342 memcpy(&tcon->fsDevInfo, response_data,
4343 sizeof(FILE_SYSTEM_DEVICE_INFO));
4344 }
4345 }
4346 cifs_buf_release(pSMB);
4347
4348 if (rc == -EAGAIN)
4349 goto QFSDeviceRetry;
4350
4351 return rc;
4352 }
4353
4354 int
4355 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
4356 {
4357 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
4358 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4359 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4360 FILE_SYSTEM_UNIX_INFO *response_data;
4361 int rc = 0;
4362 int bytes_returned = 0;
4363 __u16 params, byte_count;
4364
4365 cFYI(1, ("In QFSUnixInfo"));
4366 QFSUnixRetry:
4367 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4368 (void **) &pSMBr);
4369 if (rc)
4370 return rc;
4371
4372 params = 2; /* level */
4373 pSMB->TotalDataCount = 0;
4374 pSMB->DataCount = 0;
4375 pSMB->DataOffset = 0;
4376 pSMB->MaxParameterCount = cpu_to_le16(2);
4377 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4378 pSMB->MaxSetupCount = 0;
4379 pSMB->Reserved = 0;
4380 pSMB->Flags = 0;
4381 pSMB->Timeout = 0;
4382 pSMB->Reserved2 = 0;
4383 byte_count = params + 1 /* pad */ ;
4384 pSMB->ParameterCount = cpu_to_le16(params);
4385 pSMB->TotalParameterCount = pSMB->ParameterCount;
4386 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4387 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4388 pSMB->SetupCount = 1;
4389 pSMB->Reserved3 = 0;
4390 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4391 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4392 pSMB->hdr.smb_buf_length += byte_count;
4393 pSMB->ByteCount = cpu_to_le16(byte_count);
4394
4395 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4396 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4397 if (rc) {
4398 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
4399 } else { /* decode response */
4400 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4401
4402 if (rc || (pSMBr->ByteCount < 13)) {
4403 rc = -EIO; /* bad smb */
4404 } else {
4405 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4406 response_data =
4407 (FILE_SYSTEM_UNIX_INFO
4408 *) (((char *) &pSMBr->hdr.Protocol) +
4409 data_offset);
4410 memcpy(&tcon->fsUnixInfo, response_data,
4411 sizeof(FILE_SYSTEM_UNIX_INFO));
4412 }
4413 }
4414 cifs_buf_release(pSMB);
4415
4416 if (rc == -EAGAIN)
4417 goto QFSUnixRetry;
4418
4419
4420 return rc;
4421 }
4422
4423 int
4424 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
4425 {
4426 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
4427 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4428 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4429 int rc = 0;
4430 int bytes_returned = 0;
4431 __u16 params, param_offset, offset, byte_count;
4432
4433 cFYI(1, ("In SETFSUnixInfo"));
4434 SETFSUnixRetry:
4435 /* BB switch to small buf init to save memory */
4436 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4437 (void **) &pSMBr);
4438 if (rc)
4439 return rc;
4440
4441 params = 4; /* 2 bytes zero followed by info level. */
4442 pSMB->MaxSetupCount = 0;
4443 pSMB->Reserved = 0;
4444 pSMB->Flags = 0;
4445 pSMB->Timeout = 0;
4446 pSMB->Reserved2 = 0;
4447 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4448 - 4;
4449 offset = param_offset + params;
4450
4451 pSMB->MaxParameterCount = cpu_to_le16(4);
4452 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4453 pSMB->SetupCount = 1;
4454 pSMB->Reserved3 = 0;
4455 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4456 byte_count = 1 /* pad */ + params + 12;
4457
4458 pSMB->DataCount = cpu_to_le16(12);
4459 pSMB->ParameterCount = cpu_to_le16(params);
4460 pSMB->TotalDataCount = pSMB->DataCount;
4461 pSMB->TotalParameterCount = pSMB->ParameterCount;
4462 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4463 pSMB->DataOffset = cpu_to_le16(offset);
4464
4465 /* Params. */
4466 pSMB->FileNum = 0;
4467 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4468
4469 /* Data. */
4470 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4471 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4472 pSMB->ClientUnixCap = cpu_to_le64(cap);
4473
4474 pSMB->hdr.smb_buf_length += byte_count;
4475 pSMB->ByteCount = cpu_to_le16(byte_count);
4476
4477 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4478 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4479 if (rc) {
4480 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
4481 } else { /* decode response */
4482 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4483 if (rc) {
4484 rc = -EIO; /* bad smb */
4485 }
4486 }
4487 cifs_buf_release(pSMB);
4488
4489 if (rc == -EAGAIN)
4490 goto SETFSUnixRetry;
4491
4492 return rc;
4493 }
4494
4495
4496
4497 int
4498 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
4499 struct kstatfs *FSData)
4500 {
4501 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
4502 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4503 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4504 FILE_SYSTEM_POSIX_INFO *response_data;
4505 int rc = 0;
4506 int bytes_returned = 0;
4507 __u16 params, byte_count;
4508
4509 cFYI(1, ("In QFSPosixInfo"));
4510 QFSPosixRetry:
4511 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4512 (void **) &pSMBr);
4513 if (rc)
4514 return rc;
4515
4516 params = 2; /* level */
4517 pSMB->TotalDataCount = 0;
4518 pSMB->DataCount = 0;
4519 pSMB->DataOffset = 0;
4520 pSMB->MaxParameterCount = cpu_to_le16(2);
4521 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4522 pSMB->MaxSetupCount = 0;
4523 pSMB->Reserved = 0;
4524 pSMB->Flags = 0;
4525 pSMB->Timeout = 0;
4526 pSMB->Reserved2 = 0;
4527 byte_count = params + 1 /* pad */ ;
4528 pSMB->ParameterCount = cpu_to_le16(params);
4529 pSMB->TotalParameterCount = pSMB->ParameterCount;
4530 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4531 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4532 pSMB->SetupCount = 1;
4533 pSMB->Reserved3 = 0;
4534 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4535 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4536 pSMB->hdr.smb_buf_length += byte_count;
4537 pSMB->ByteCount = cpu_to_le16(byte_count);
4538
4539 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4540 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4541 if (rc) {
4542 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
4543 } else { /* decode response */
4544 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4545
4546 if (rc || (pSMBr->ByteCount < 13)) {
4547 rc = -EIO; /* bad smb */
4548 } else {
4549 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4550 response_data =
4551 (FILE_SYSTEM_POSIX_INFO
4552 *) (((char *) &pSMBr->hdr.Protocol) +
4553 data_offset);
4554 FSData->f_bsize =
4555 le32_to_cpu(response_data->BlockSize);
4556 FSData->f_blocks =
4557 le64_to_cpu(response_data->TotalBlocks);
4558 FSData->f_bfree =
4559 le64_to_cpu(response_data->BlocksAvail);
4560 if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4561 FSData->f_bavail = FSData->f_bfree;
4562 } else {
4563 FSData->f_bavail =
4564 le64_to_cpu(response_data->UserBlocksAvail);
4565 }
4566 if (response_data->TotalFileNodes != cpu_to_le64(-1))
4567 FSData->f_files =
4568 le64_to_cpu(response_data->TotalFileNodes);
4569 if (response_data->FreeFileNodes != cpu_to_le64(-1))
4570 FSData->f_ffree =
4571 le64_to_cpu(response_data->FreeFileNodes);
4572 }
4573 }
4574 cifs_buf_release(pSMB);
4575
4576 if (rc == -EAGAIN)
4577 goto QFSPosixRetry;
4578
4579 return rc;
4580 }
4581
4582
4583 /* We can not use write of zero bytes trick to
4584 set file size due to need for large file support. Also note that
4585 this SetPathInfo is preferred to SetFileInfo based method in next
4586 routine which is only needed to work around a sharing violation bug
4587 in Samba which this routine can run into */
4588
4589 int
4590 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4591 __u64 size, int SetAllocation,
4592 const struct nls_table *nls_codepage, int remap)
4593 {
4594 struct smb_com_transaction2_spi_req *pSMB = NULL;
4595 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4596 struct file_end_of_file_info *parm_data;
4597 int name_len;
4598 int rc = 0;
4599 int bytes_returned = 0;
4600 __u16 params, byte_count, data_count, param_offset, offset;
4601
4602 cFYI(1, ("In SetEOF"));
4603 SetEOFRetry:
4604 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4605 (void **) &pSMBr);
4606 if (rc)
4607 return rc;
4608
4609 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4610 name_len =
4611 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4612 PATH_MAX, nls_codepage, remap);
4613 name_len++; /* trailing null */
4614 name_len *= 2;
4615 } else { /* BB improve the check for buffer overruns BB */
4616 name_len = strnlen(fileName, PATH_MAX);
4617 name_len++; /* trailing null */
4618 strncpy(pSMB->FileName, fileName, name_len);
4619 }
4620 params = 6 + name_len;
4621 data_count = sizeof(struct file_end_of_file_info);
4622 pSMB->MaxParameterCount = cpu_to_le16(2);
4623 pSMB->MaxDataCount = cpu_to_le16(4100);
4624 pSMB->MaxSetupCount = 0;
4625 pSMB->Reserved = 0;
4626 pSMB->Flags = 0;
4627 pSMB->Timeout = 0;
4628 pSMB->Reserved2 = 0;
4629 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4630 InformationLevel) - 4;
4631 offset = param_offset + params;
4632 if (SetAllocation) {
4633 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4634 pSMB->InformationLevel =
4635 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4636 else
4637 pSMB->InformationLevel =
4638 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4639 } else /* Set File Size */ {
4640 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4641 pSMB->InformationLevel =
4642 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4643 else
4644 pSMB->InformationLevel =
4645 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4646 }
4647
4648 parm_data =
4649 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4650 offset);
4651 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4652 pSMB->DataOffset = cpu_to_le16(offset);
4653 pSMB->SetupCount = 1;
4654 pSMB->Reserved3 = 0;
4655 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4656 byte_count = 3 /* pad */ + params + data_count;
4657 pSMB->DataCount = cpu_to_le16(data_count);
4658 pSMB->TotalDataCount = pSMB->DataCount;
4659 pSMB->ParameterCount = cpu_to_le16(params);
4660 pSMB->TotalParameterCount = pSMB->ParameterCount;
4661 pSMB->Reserved4 = 0;
4662 pSMB->hdr.smb_buf_length += byte_count;
4663 parm_data->FileSize = cpu_to_le64(size);
4664 pSMB->ByteCount = cpu_to_le16(byte_count);
4665 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4666 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4667 if (rc) {
4668 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4669 }
4670
4671 cifs_buf_release(pSMB);
4672
4673 if (rc == -EAGAIN)
4674 goto SetEOFRetry;
4675
4676 return rc;
4677 }
4678
4679 int
4680 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4681 __u16 fid, __u32 pid_of_opener, int SetAllocation)
4682 {
4683 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4684 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4685 char *data_offset;
4686 struct file_end_of_file_info *parm_data;
4687 int rc = 0;
4688 int bytes_returned = 0;
4689 __u16 params, param_offset, offset, byte_count, count;
4690
4691 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4692 (long long)size));
4693 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4694
4695 if (rc)
4696 return rc;
4697
4698 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4699
4700 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4701 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4702
4703 params = 6;
4704 pSMB->MaxSetupCount = 0;
4705 pSMB->Reserved = 0;
4706 pSMB->Flags = 0;
4707 pSMB->Timeout = 0;
4708 pSMB->Reserved2 = 0;
4709 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4710 offset = param_offset + params;
4711
4712 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4713
4714 count = sizeof(struct file_end_of_file_info);
4715 pSMB->MaxParameterCount = cpu_to_le16(2);
4716 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4717 pSMB->SetupCount = 1;
4718 pSMB->Reserved3 = 0;
4719 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4720 byte_count = 3 /* pad */ + params + count;
4721 pSMB->DataCount = cpu_to_le16(count);
4722 pSMB->ParameterCount = cpu_to_le16(params);
4723 pSMB->TotalDataCount = pSMB->DataCount;
4724 pSMB->TotalParameterCount = pSMB->ParameterCount;
4725 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4726 parm_data =
4727 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
4728 + offset);
4729 pSMB->DataOffset = cpu_to_le16(offset);
4730 parm_data->FileSize = cpu_to_le64(size);
4731 pSMB->Fid = fid;
4732 if (SetAllocation) {
4733 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4734 pSMB->InformationLevel =
4735 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4736 else
4737 pSMB->InformationLevel =
4738 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4739 } else /* Set File Size */ {
4740 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4741 pSMB->InformationLevel =
4742 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4743 else
4744 pSMB->InformationLevel =
4745 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4746 }
4747 pSMB->Reserved4 = 0;
4748 pSMB->hdr.smb_buf_length += byte_count;
4749 pSMB->ByteCount = cpu_to_le16(byte_count);
4750 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4751 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4752 if (rc) {
4753 cFYI(1,
4754 ("Send error in SetFileInfo (SetFileSize) = %d",
4755 rc));
4756 }
4757
4758 if (pSMB)
4759 cifs_small_buf_release(pSMB);
4760
4761 /* Note: On -EAGAIN error only caller can retry on handle based calls
4762 since file handle passed in no longer valid */
4763
4764 return rc;
4765 }
4766
4767 /* Some legacy servers such as NT4 require that the file times be set on
4768 an open handle, rather than by pathname - this is awkward due to
4769 potential access conflicts on the open, but it is unavoidable for these
4770 old servers since the only other choice is to go from 100 nanosecond DCE
4771 time and resort to the original setpathinfo level which takes the ancient
4772 DOS time format with 2 second granularity */
4773 int
4774 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
4775 const FILE_BASIC_INFO *data, __u16 fid)
4776 {
4777 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4778 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4779 char *data_offset;
4780 int rc = 0;
4781 int bytes_returned = 0;
4782 __u16 params, param_offset, offset, byte_count, count;
4783
4784 cFYI(1, ("Set Times (via SetFileInfo)"));
4785 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4786
4787 if (rc)
4788 return rc;
4789
4790 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4791
4792 /* At this point there is no need to override the current pid
4793 with the pid of the opener, but that could change if we someday
4794 use an existing handle (rather than opening one on the fly) */
4795 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4796 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
4797
4798 params = 6;
4799 pSMB->MaxSetupCount = 0;
4800 pSMB->Reserved = 0;
4801 pSMB->Flags = 0;
4802 pSMB->Timeout = 0;
4803 pSMB->Reserved2 = 0;
4804 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4805 offset = param_offset + params;
4806
4807 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4808
4809 count = sizeof(FILE_BASIC_INFO);
4810 pSMB->MaxParameterCount = cpu_to_le16(2);
4811 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4812 pSMB->SetupCount = 1;
4813 pSMB->Reserved3 = 0;
4814 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4815 byte_count = 3 /* pad */ + params + count;
4816 pSMB->DataCount = cpu_to_le16(count);
4817 pSMB->ParameterCount = cpu_to_le16(params);
4818 pSMB->TotalDataCount = pSMB->DataCount;
4819 pSMB->TotalParameterCount = pSMB->ParameterCount;
4820 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4821 pSMB->DataOffset = cpu_to_le16(offset);
4822 pSMB->Fid = fid;
4823 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4824 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4825 else
4826 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4827 pSMB->Reserved4 = 0;
4828 pSMB->hdr.smb_buf_length += byte_count;
4829 pSMB->ByteCount = cpu_to_le16(byte_count);
4830 memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4831 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4832 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4833 if (rc) {
4834 cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
4835 }
4836
4837 cifs_small_buf_release(pSMB);
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, -1);
5130 if (rc) {
5131 cFYI(1, ("Error in Notify = %d", rc));
5132 } else {
5133 /* Add file to outstanding requests */
5134 /* BB change to kmem cache alloc */
5135 dnotify_req = kmalloc(
5136 sizeof(struct dir_notify_req),
5137 GFP_KERNEL);
5138 if (dnotify_req) {
5139 dnotify_req->Pid = pSMB->hdr.Pid;
5140 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
5141 dnotify_req->Mid = pSMB->hdr.Mid;
5142 dnotify_req->Tid = pSMB->hdr.Tid;
5143 dnotify_req->Uid = pSMB->hdr.Uid;
5144 dnotify_req->netfid = netfid;
5145 dnotify_req->pfile = pfile;
5146 dnotify_req->filter = filter;
5147 dnotify_req->multishot = multishot;
5148 spin_lock(&GlobalMid_Lock);
5149 list_add_tail(&dnotify_req->lhead,
5150 &GlobalDnotifyReqList);
5151 spin_unlock(&GlobalMid_Lock);
5152 } else
5153 rc = -ENOMEM;
5154 }
5155 cifs_buf_release(pSMB);
5156 return rc;
5157 }
5158 #ifdef CONFIG_CIFS_XATTR
5159 ssize_t
5160 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
5161 const unsigned char *searchName,
5162 char *EAData, size_t buf_size,
5163 const struct nls_table *nls_codepage, int remap)
5164 {
5165 /* BB assumes one setup word */
5166 TRANSACTION2_QPI_REQ *pSMB = NULL;
5167 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5168 int rc = 0;
5169 int bytes_returned;
5170 int name_len;
5171 struct fea *temp_fea;
5172 char *temp_ptr;
5173 __u16 params, byte_count;
5174
5175 cFYI(1, ("In Query All EAs path %s", searchName));
5176 QAllEAsRetry:
5177 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5178 (void **) &pSMBr);
5179 if (rc)
5180 return rc;
5181
5182 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5183 name_len =
5184 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5185 PATH_MAX, nls_codepage, remap);
5186 name_len++; /* trailing null */
5187 name_len *= 2;
5188 } else { /* BB improve the check for buffer overruns BB */
5189 name_len = strnlen(searchName, PATH_MAX);
5190 name_len++; /* trailing null */
5191 strncpy(pSMB->FileName, searchName, name_len);
5192 }
5193
5194 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5195 pSMB->TotalDataCount = 0;
5196 pSMB->MaxParameterCount = cpu_to_le16(2);
5197 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5198 pSMB->MaxSetupCount = 0;
5199 pSMB->Reserved = 0;
5200 pSMB->Flags = 0;
5201 pSMB->Timeout = 0;
5202 pSMB->Reserved2 = 0;
5203 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5204 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5205 pSMB->DataCount = 0;
5206 pSMB->DataOffset = 0;
5207 pSMB->SetupCount = 1;
5208 pSMB->Reserved3 = 0;
5209 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5210 byte_count = params + 1 /* pad */ ;
5211 pSMB->TotalParameterCount = cpu_to_le16(params);
5212 pSMB->ParameterCount = pSMB->TotalParameterCount;
5213 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5214 pSMB->Reserved4 = 0;
5215 pSMB->hdr.smb_buf_length += byte_count;
5216 pSMB->ByteCount = cpu_to_le16(byte_count);
5217
5218 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5219 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5220 if (rc) {
5221 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
5222 } else { /* decode response */
5223 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5224
5225 /* BB also check enough total bytes returned */
5226 /* BB we need to improve the validity checking
5227 of these trans2 responses */
5228 if (rc || (pSMBr->ByteCount < 4))
5229 rc = -EIO; /* bad smb */
5230 /* else if (pFindData){
5231 memcpy((char *) pFindData,
5232 (char *) &pSMBr->hdr.Protocol +
5233 data_offset, kl);
5234 }*/ else {
5235 /* check that length of list is not more than bcc */
5236 /* check that each entry does not go beyond length
5237 of list */
5238 /* check that each element of each entry does not
5239 go beyond end of list */
5240 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5241 struct fealist *ea_response_data;
5242 rc = 0;
5243 /* validate_trans2_offsets() */
5244 /* BB check if start of smb + data_offset > &bcc+ bcc */
5245 ea_response_data = (struct fealist *)
5246 (((char *) &pSMBr->hdr.Protocol) +
5247 data_offset);
5248 name_len = le32_to_cpu(ea_response_data->list_len);
5249 cFYI(1, ("ea length %d", name_len));
5250 if (name_len <= 8) {
5251 /* returned EA size zeroed at top of function */
5252 cFYI(1, ("empty EA list returned from server"));
5253 } else {
5254 /* account for ea list len */
5255 name_len -= 4;
5256 temp_fea = ea_response_data->list;
5257 temp_ptr = (char *)temp_fea;
5258 while (name_len > 0) {
5259 __u16 value_len;
5260 name_len -= 4;
5261 temp_ptr += 4;
5262 rc += temp_fea->name_len;
5263 /* account for prefix user. and trailing null */
5264 rc = rc + 5 + 1;
5265 if (rc < (int)buf_size) {
5266 memcpy(EAData, "user.", 5);
5267 EAData += 5;
5268 memcpy(EAData, temp_ptr,
5269 temp_fea->name_len);
5270 EAData += temp_fea->name_len;
5271 /* null terminate name */
5272 *EAData = 0;
5273 EAData = EAData + 1;
5274 } else if (buf_size == 0) {
5275 /* skip copy - calc size only */
5276 } else {
5277 /* stop before overrun buffer */
5278 rc = -ERANGE;
5279 break;
5280 }
5281 name_len -= temp_fea->name_len;
5282 temp_ptr += temp_fea->name_len;
5283 /* account for trailing null */
5284 name_len--;
5285 temp_ptr++;
5286 value_len =
5287 le16_to_cpu(temp_fea->value_len);
5288 name_len -= value_len;
5289 temp_ptr += value_len;
5290 /* BB check that temp_ptr is still
5291 within the SMB BB*/
5292
5293 /* no trailing null to account for
5294 in value len */
5295 /* go on to next EA */
5296 temp_fea = (struct fea *)temp_ptr;
5297 }
5298 }
5299 }
5300 }
5301 if (pSMB)
5302 cifs_buf_release(pSMB);
5303 if (rc == -EAGAIN)
5304 goto QAllEAsRetry;
5305
5306 return (ssize_t)rc;
5307 }
5308
5309 ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
5310 const unsigned char *searchName, const unsigned char *ea_name,
5311 unsigned char *ea_value, size_t buf_size,
5312 const struct nls_table *nls_codepage, int remap)
5313 {
5314 TRANSACTION2_QPI_REQ *pSMB = NULL;
5315 TRANSACTION2_QPI_RSP *pSMBr = NULL;
5316 int rc = 0;
5317 int bytes_returned;
5318 int name_len;
5319 struct fea *temp_fea;
5320 char *temp_ptr;
5321 __u16 params, byte_count;
5322
5323 cFYI(1, ("In Query EA path %s", searchName));
5324 QEARetry:
5325 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5326 (void **) &pSMBr);
5327 if (rc)
5328 return rc;
5329
5330 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5331 name_len =
5332 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5333 PATH_MAX, nls_codepage, remap);
5334 name_len++; /* trailing null */
5335 name_len *= 2;
5336 } else { /* BB improve the check for buffer overruns BB */
5337 name_len = strnlen(searchName, PATH_MAX);
5338 name_len++; /* trailing null */
5339 strncpy(pSMB->FileName, searchName, name_len);
5340 }
5341
5342 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5343 pSMB->TotalDataCount = 0;
5344 pSMB->MaxParameterCount = cpu_to_le16(2);
5345 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5346 pSMB->MaxSetupCount = 0;
5347 pSMB->Reserved = 0;
5348 pSMB->Flags = 0;
5349 pSMB->Timeout = 0;
5350 pSMB->Reserved2 = 0;
5351 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5352 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5353 pSMB->DataCount = 0;
5354 pSMB->DataOffset = 0;
5355 pSMB->SetupCount = 1;
5356 pSMB->Reserved3 = 0;
5357 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5358 byte_count = params + 1 /* pad */ ;
5359 pSMB->TotalParameterCount = cpu_to_le16(params);
5360 pSMB->ParameterCount = pSMB->TotalParameterCount;
5361 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5362 pSMB->Reserved4 = 0;
5363 pSMB->hdr.smb_buf_length += byte_count;
5364 pSMB->ByteCount = cpu_to_le16(byte_count);
5365
5366 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5367 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5368 if (rc) {
5369 cFYI(1, ("Send error in Query EA = %d", rc));
5370 } else { /* decode response */
5371 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5372
5373 /* BB also check enough total bytes returned */
5374 /* BB we need to improve the validity checking
5375 of these trans2 responses */
5376 if (rc || (pSMBr->ByteCount < 4))
5377 rc = -EIO; /* bad smb */
5378 /* else if (pFindData){
5379 memcpy((char *) pFindData,
5380 (char *) &pSMBr->hdr.Protocol +
5381 data_offset, kl);
5382 }*/ else {
5383 /* check that length of list is not more than bcc */
5384 /* check that each entry does not go beyond length
5385 of list */
5386 /* check that each element of each entry does not
5387 go beyond end of list */
5388 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5389 struct fealist *ea_response_data;
5390 rc = -ENODATA;
5391 /* validate_trans2_offsets() */
5392 /* BB check if start of smb + data_offset > &bcc+ bcc*/
5393 ea_response_data = (struct fealist *)
5394 (((char *) &pSMBr->hdr.Protocol) +
5395 data_offset);
5396 name_len = le32_to_cpu(ea_response_data->list_len);
5397 cFYI(1, ("ea length %d", name_len));
5398 if (name_len <= 8) {
5399 /* returned EA size zeroed at top of function */
5400 cFYI(1, ("empty EA list returned from server"));
5401 } else {
5402 /* account for ea list len */
5403 name_len -= 4;
5404 temp_fea = ea_response_data->list;
5405 temp_ptr = (char *)temp_fea;
5406 /* loop through checking if we have a matching
5407 name and then return the associated value */
5408 while (name_len > 0) {
5409 __u16 value_len;
5410 name_len -= 4;
5411 temp_ptr += 4;
5412 value_len =
5413 le16_to_cpu(temp_fea->value_len);
5414 /* BB validate that value_len falls within SMB,
5415 even though maximum for name_len is 255 */
5416 if (memcmp(temp_fea->name, ea_name,
5417 temp_fea->name_len) == 0) {
5418 /* found a match */
5419 rc = value_len;
5420 /* account for prefix user. and trailing null */
5421 if (rc <= (int)buf_size) {
5422 memcpy(ea_value,
5423 temp_fea->name+temp_fea->name_len+1,
5424 rc);
5425 /* ea values, unlike ea
5426 names, are not null
5427 terminated */
5428 } else if (buf_size == 0) {
5429 /* skip copy - calc size only */
5430 } else {
5431 /* stop before overrun buffer */
5432 rc = -ERANGE;
5433 }
5434 break;
5435 }
5436 name_len -= temp_fea->name_len;
5437 temp_ptr += temp_fea->name_len;
5438 /* account for trailing null */
5439 name_len--;
5440 temp_ptr++;
5441 name_len -= value_len;
5442 temp_ptr += value_len;
5443 /* No trailing null to account for in
5444 value_len. Go on to next EA */
5445 temp_fea = (struct fea *)temp_ptr;
5446 }
5447 }
5448 }
5449 }
5450 if (pSMB)
5451 cifs_buf_release(pSMB);
5452 if (rc == -EAGAIN)
5453 goto QEARetry;
5454
5455 return (ssize_t)rc;
5456 }
5457
5458 int
5459 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
5460 const char *ea_name, const void *ea_value,
5461 const __u16 ea_value_len, const struct nls_table *nls_codepage,
5462 int remap)
5463 {
5464 struct smb_com_transaction2_spi_req *pSMB = NULL;
5465 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5466 struct fealist *parm_data;
5467 int name_len;
5468 int rc = 0;
5469 int bytes_returned = 0;
5470 __u16 params, param_offset, byte_count, offset, count;
5471
5472 cFYI(1, ("In SetEA"));
5473 SetEARetry:
5474 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5475 (void **) &pSMBr);
5476 if (rc)
5477 return rc;
5478
5479 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5480 name_len =
5481 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5482 PATH_MAX, nls_codepage, remap);
5483 name_len++; /* trailing null */
5484 name_len *= 2;
5485 } else { /* BB improve the check for buffer overruns BB */
5486 name_len = strnlen(fileName, PATH_MAX);
5487 name_len++; /* trailing null */
5488 strncpy(pSMB->FileName, fileName, name_len);
5489 }
5490
5491 params = 6 + name_len;
5492
5493 /* done calculating parms using name_len of file name,
5494 now use name_len to calculate length of ea name
5495 we are going to create in the inode xattrs */
5496 if (ea_name == NULL)
5497 name_len = 0;
5498 else
5499 name_len = strnlen(ea_name, 255);
5500
5501 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
5502 pSMB->MaxParameterCount = cpu_to_le16(2);
5503 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
5504 pSMB->MaxSetupCount = 0;
5505 pSMB->Reserved = 0;
5506 pSMB->Flags = 0;
5507 pSMB->Timeout = 0;
5508 pSMB->Reserved2 = 0;
5509 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5510 InformationLevel) - 4;
5511 offset = param_offset + params;
5512 pSMB->InformationLevel =
5513 cpu_to_le16(SMB_SET_FILE_EA);
5514
5515 parm_data =
5516 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
5517 offset);
5518 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5519 pSMB->DataOffset = cpu_to_le16(offset);
5520 pSMB->SetupCount = 1;
5521 pSMB->Reserved3 = 0;
5522 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5523 byte_count = 3 /* pad */ + params + count;
5524 pSMB->DataCount = cpu_to_le16(count);
5525 parm_data->list_len = cpu_to_le32(count);
5526 parm_data->list[0].EA_flags = 0;
5527 /* we checked above that name len is less than 255 */
5528 parm_data->list[0].name_len = (__u8)name_len;
5529 /* EA names are always ASCII */
5530 if (ea_name)
5531 strncpy(parm_data->list[0].name, ea_name, name_len);
5532 parm_data->list[0].name[name_len] = 0;
5533 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
5534 /* caller ensures that ea_value_len is less than 64K but
5535 we need to ensure that it fits within the smb */
5536
5537 /*BB add length check to see if it would fit in
5538 negotiated SMB buffer size BB */
5539 /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5540 if (ea_value_len)
5541 memcpy(parm_data->list[0].name+name_len+1,
5542 ea_value, ea_value_len);
5543
5544 pSMB->TotalDataCount = pSMB->DataCount;
5545 pSMB->ParameterCount = cpu_to_le16(params);
5546 pSMB->TotalParameterCount = pSMB->ParameterCount;
5547 pSMB->Reserved4 = 0;
5548 pSMB->hdr.smb_buf_length += byte_count;
5549 pSMB->ByteCount = cpu_to_le16(byte_count);
5550 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5551 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5552 if (rc) {
5553 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
5554 }
5555
5556 cifs_buf_release(pSMB);
5557
5558 if (rc == -EAGAIN)
5559 goto SetEARetry;
5560
5561 return rc;
5562 }
5563
5564 #endif
WRT350N Kernel Patches