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