aboutsummaryrefslogtreecommitdiffstats
path: root/fs/cifs/cifssmb.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/cifs/cifssmb.c')
-rw-r--r--fs/cifs/cifssmb.c4186
1 files changed, 4186 insertions, 0 deletions
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
new file mode 100644
index 000000000000..df6a619a6821
--- /dev/null
+++ b/fs/cifs/cifssmb.c
@@ -0,0 +1,4186 @@
1/*
2 * fs/cifs/cifssmb.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2005
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 different for reconnection purposes since we never want */
28 /* to reuse a stale file handle and the caller knows the file handle */
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
41#ifdef CONFIG_CIFS_POSIX
42static struct {
43 int index;
44 char *name;
45} protocols[] = {
46 {CIFS_PROT, "\2NT LM 0.12"},
47 {CIFS_PROT, "\2POSIX 2"},
48 {BAD_PROT, "\2"}
49};
50#else
51static struct {
52 int index;
53 char *name;
54} protocols[] = {
55 {CIFS_PROT, "\2NT LM 0.12"},
56 {BAD_PROT, "\2"}
57};
58#endif
59
60
61/* Mark as invalid, all open files on tree connections since they
62 were closed when session to server was lost */
63static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
64{
65 struct cifsFileInfo *open_file = NULL;
66 struct list_head * tmp;
67 struct list_head * tmp1;
68
69/* list all files open on tree connection and mark them invalid */
70 write_lock(&GlobalSMBSeslock);
71 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
72 open_file = list_entry(tmp,struct cifsFileInfo, tlist);
73 if(open_file) {
74 open_file->invalidHandle = TRUE;
75 }
76 }
77 write_unlock(&GlobalSMBSeslock);
78 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted to this tcon */
79}
80
81/* If the return code is zero, this function must fill in request_buf pointer */
82static int
83small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
84 void **request_buf /* returned */)
85{
86 int rc = 0;
87
88 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
89 check for tcp and smb session status done differently
90 for those three - in the calling routine */
91 if(tcon) {
92 if((tcon->ses) && (tcon->ses->server)){
93 struct nls_table *nls_codepage;
94 /* Give Demultiplex thread up to 10 seconds to
95 reconnect, should be greater than cifs socket
96 timeout which is 7 seconds */
97 while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
98 wait_event_interruptible_timeout(tcon->ses->server->response_q,
99 (tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
100 if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
101 /* on "soft" mounts we wait once */
102 if((tcon->retry == FALSE) ||
103 (tcon->ses->status == CifsExiting)) {
104 cFYI(1,("gave up waiting on reconnect in smb_init"));
105 return -EHOSTDOWN;
106 } /* else "hard" mount - keep retrying until
107 process is killed or server comes back up */
108 } else /* TCP session is reestablished now */
109 break;
110
111 }
112
113 nls_codepage = load_nls_default();
114 /* need to prevent multiple threads trying to
115 simultaneously reconnect the same SMB session */
116 down(&tcon->ses->sesSem);
117 if(tcon->ses->status == CifsNeedReconnect)
118 rc = cifs_setup_session(0, tcon->ses, nls_codepage);
119 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
120 mark_open_files_invalid(tcon);
121 rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon,
122 nls_codepage);
123 up(&tcon->ses->sesSem);
124 if(rc == 0)
125 atomic_inc(&tconInfoReconnectCount);
126
127 cFYI(1, ("reconnect tcon rc = %d", rc));
128 /* Removed call to reopen open files here -
129 it is safer (and faster) to reopen files
130 one at a time as needed in read and write */
131
132 /* Check if handle based operation so we
133 know whether we can continue or not without
134 returning to caller to reset file handle */
135 switch(smb_command) {
136 case SMB_COM_READ_ANDX:
137 case SMB_COM_WRITE_ANDX:
138 case SMB_COM_CLOSE:
139 case SMB_COM_FIND_CLOSE2:
140 case SMB_COM_LOCKING_ANDX: {
141 unload_nls(nls_codepage);
142 return -EAGAIN;
143 }
144 }
145 } else {
146 up(&tcon->ses->sesSem);
147 }
148 unload_nls(nls_codepage);
149
150 } else {
151 return -EIO;
152 }
153 }
154 if(rc)
155 return rc;
156
157 *request_buf = cifs_small_buf_get();
158 if (*request_buf == NULL) {
159 /* BB should we add a retry in here if not a writepage? */
160 return -ENOMEM;
161 }
162
163 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,wct);
164
165#ifdef CONFIG_CIFS_STATS
166 if(tcon != NULL) {
167 atomic_inc(&tcon->num_smbs_sent);
168 }
169#endif /* CONFIG_CIFS_STATS */
170 return rc;
171}
172
173/* If the return code is zero, this function must fill in request_buf pointer */
174static int
175smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
176 void **request_buf /* returned */ ,
177 void **response_buf /* returned */ )
178{
179 int rc = 0;
180
181 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
182 check for tcp and smb session status done differently
183 for those three - in the calling routine */
184 if(tcon) {
185 if((tcon->ses) && (tcon->ses->server)){
186 struct nls_table *nls_codepage;
187 /* Give Demultiplex thread up to 10 seconds to
188 reconnect, should be greater than cifs socket
189 timeout which is 7 seconds */
190 while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
191 wait_event_interruptible_timeout(tcon->ses->server->response_q,
192 (tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
193 if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
194 /* on "soft" mounts we wait once */
195 if((tcon->retry == FALSE) ||
196 (tcon->ses->status == CifsExiting)) {
197 cFYI(1,("gave up waiting on reconnect in smb_init"));
198 return -EHOSTDOWN;
199 } /* else "hard" mount - keep retrying until
200 process is killed or server comes back up */
201 } else /* TCP session is reestablished now */
202 break;
203
204 }
205
206 nls_codepage = load_nls_default();
207 /* need to prevent multiple threads trying to
208 simultaneously reconnect the same SMB session */
209 down(&tcon->ses->sesSem);
210 if(tcon->ses->status == CifsNeedReconnect)
211 rc = cifs_setup_session(0, tcon->ses, nls_codepage);
212 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
213 mark_open_files_invalid(tcon);
214 rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon,
215 nls_codepage);
216 up(&tcon->ses->sesSem);
217 if(rc == 0)
218 atomic_inc(&tconInfoReconnectCount);
219
220 cFYI(1, ("reconnect tcon rc = %d", rc));
221 /* Removed call to reopen open files here -
222 it is safer (and faster) to reopen files
223 one at a time as needed in read and write */
224
225 /* Check if handle based operation so we
226 know whether we can continue or not without
227 returning to caller to reset file handle */
228 switch(smb_command) {
229 case SMB_COM_READ_ANDX:
230 case SMB_COM_WRITE_ANDX:
231 case SMB_COM_CLOSE:
232 case SMB_COM_FIND_CLOSE2:
233 case SMB_COM_LOCKING_ANDX: {
234 unload_nls(nls_codepage);
235 return -EAGAIN;
236 }
237 }
238 } else {
239 up(&tcon->ses->sesSem);
240 }
241 unload_nls(nls_codepage);
242
243 } else {
244 return -EIO;
245 }
246 }
247 if(rc)
248 return rc;
249
250 *request_buf = cifs_buf_get();
251 if (*request_buf == NULL) {
252 /* BB should we add a retry in here if not a writepage? */
253 return -ENOMEM;
254 }
255 /* Although the original thought was we needed the response buf for */
256 /* potential retries of smb operations it turns out we can determine */
257 /* from the mid flags when the request buffer can be resent without */
258 /* having to use a second distinct buffer for the response */
259 *response_buf = *request_buf;
260
261 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
262 wct /*wct */ );
263
264#ifdef CONFIG_CIFS_STATS
265 if(tcon != NULL) {
266 atomic_inc(&tcon->num_smbs_sent);
267 }
268#endif /* CONFIG_CIFS_STATS */
269 return rc;
270}
271
272static int validate_t2(struct smb_t2_rsp * pSMB)
273{
274 int rc = -EINVAL;
275 int total_size;
276 char * pBCC;
277
278 /* check for plausible wct, bcc and t2 data and parm sizes */
279 /* check for parm and data offset going beyond end of smb */
280 if(pSMB->hdr.WordCount >= 10) {
281 if((le16_to_cpu(pSMB->t2_rsp.ParameterOffset) <= 1024) &&
282 (le16_to_cpu(pSMB->t2_rsp.DataOffset) <= 1024)) {
283 /* check that bcc is at least as big as parms + data */
284 /* check that bcc is less than negotiated smb buffer */
285 total_size = le16_to_cpu(pSMB->t2_rsp.ParameterCount);
286 if(total_size < 512) {
287 total_size+=le16_to_cpu(pSMB->t2_rsp.DataCount);
288 /* BCC le converted in SendReceive */
289 pBCC = (pSMB->hdr.WordCount * 2) + sizeof(struct smb_hdr) +
290 (char *)pSMB;
291 if((total_size <= (*(u16 *)pBCC)) &&
292 (total_size <
293 CIFSMaxBufSize+MAX_CIFS_HDR_SIZE)) {
294 return 0;
295 }
296
297 }
298 }
299 }
300 cifs_dump_mem("Invalid transact2 SMB: ",(char *)pSMB,
301 sizeof(struct smb_t2_rsp) + 16);
302 return rc;
303}
304int
305CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
306{
307 NEGOTIATE_REQ *pSMB;
308 NEGOTIATE_RSP *pSMBr;
309 int rc = 0;
310 int bytes_returned;
311 struct TCP_Server_Info * server;
312 u16 count;
313
314 if(ses->server)
315 server = ses->server;
316 else {
317 rc = -EIO;
318 return rc;
319 }
320 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
321 (void **) &pSMB, (void **) &pSMBr);
322 if (rc)
323 return rc;
324
325 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
326 if (extended_security)
327 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
328
329 count = strlen(protocols[0].name) + 1;
330 strncpy(pSMB->DialectsArray, protocols[0].name, 30);
331 /* null guaranteed to be at end of source and target buffers anyway */
332
333 pSMB->hdr.smb_buf_length += count;
334 pSMB->ByteCount = cpu_to_le16(count);
335
336 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
337 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
338 if (rc == 0) {
339 server->secMode = pSMBr->SecurityMode;
340 server->secType = NTLM; /* BB override default for NTLMv2 or krb*/
341 /* one byte - no need to convert this or EncryptionKeyLen from le,*/
342 server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
343 /* probably no need to store and check maxvcs */
344 server->maxBuf =
345 min(le32_to_cpu(pSMBr->MaxBufferSize),
346 (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
347 server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
348 cFYI(0, ("Max buf = %d ", ses->server->maxBuf));
349 GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
350 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
351 server->timeZone = le16_to_cpu(pSMBr->ServerTimeZone);
352 /* BB with UTC do we ever need to be using srvr timezone? */
353 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
354 memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
355 CIFS_CRYPTO_KEY_SIZE);
356 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
357 && (pSMBr->EncryptionKeyLength == 0)) {
358 /* decode security blob */
359 } else
360 rc = -EIO;
361
362 /* BB might be helpful to save off the domain of server here */
363
364 if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
365 (server->capabilities & CAP_EXTENDED_SECURITY)) {
366 count = pSMBr->ByteCount;
367 if (count < 16)
368 rc = -EIO;
369 else if (count == 16) {
370 server->secType = RawNTLMSSP;
371 if (server->socketUseCount.counter > 1) {
372 if (memcmp
373 (server->server_GUID,
374 pSMBr->u.extended_response.
375 GUID, 16) != 0) {
376 cFYI(1,
377 ("UID of server does not match previous connection to same ip address"));
378 memcpy(server->
379 server_GUID,
380 pSMBr->u.
381 extended_response.
382 GUID, 16);
383 }
384 } else
385 memcpy(server->server_GUID,
386 pSMBr->u.extended_response.
387 GUID, 16);
388 } else {
389 rc = decode_negTokenInit(pSMBr->u.
390 extended_response.
391 SecurityBlob,
392 count - 16,
393 &server->secType);
394 if(rc == 1) {
395 /* BB Need to fill struct for sessetup here */
396 rc = -EOPNOTSUPP;
397 } else {
398 rc = -EINVAL;
399 }
400 }
401 } else
402 server->capabilities &= ~CAP_EXTENDED_SECURITY;
403 if(sign_CIFS_PDUs == FALSE) {
404 if(server->secMode & SECMODE_SIGN_REQUIRED)
405 cERROR(1,
406 ("Server requires /proc/fs/cifs/PacketSigningEnabled"));
407 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
408 } else if(sign_CIFS_PDUs == 1) {
409 if((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
410 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
411 }
412
413 }
414 if (pSMB)
415 cifs_buf_release(pSMB);
416 return rc;
417}
418
419int
420CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
421{
422 struct smb_hdr *smb_buffer;
423 struct smb_hdr *smb_buffer_response; /* BB removeme BB */
424 int rc = 0;
425 int length;
426
427 cFYI(1, ("In tree disconnect"));
428 /*
429 * If last user of the connection and
430 * connection alive - disconnect it
431 * If this is the last connection on the server session disconnect it
432 * (and inside session disconnect we should check if tcp socket needs
433 * to be freed and kernel thread woken up).
434 */
435 if (tcon)
436 down(&tcon->tconSem);
437 else
438 return -EIO;
439
440 atomic_dec(&tcon->useCount);
441 if (atomic_read(&tcon->useCount) > 0) {
442 up(&tcon->tconSem);
443 return -EBUSY;
444 }
445
446 /* No need to return error on this operation if tid invalidated and
447 closed on server already e.g. due to tcp session crashing */
448 if(tcon->tidStatus == CifsNeedReconnect) {
449 up(&tcon->tconSem);
450 return 0;
451 }
452
453 if((tcon->ses == NULL) || (tcon->ses->server == NULL)) {
454 up(&tcon->tconSem);
455 return -EIO;
456 }
457 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon, (void **)&smb_buffer);
458 if (rc) {
459 up(&tcon->tconSem);
460 return rc;
461 } else {
462 smb_buffer_response = smb_buffer; /* BB removeme BB */
463 }
464 rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
465 &length, 0);
466 if (rc)
467 cFYI(1, (" Tree disconnect failed %d", rc));
468
469 if (smb_buffer)
470 cifs_small_buf_release(smb_buffer);
471 up(&tcon->tconSem);
472
473 /* No need to return error on this operation if tid invalidated and
474 closed on server already e.g. due to tcp session crashing */
475 if (rc == -EAGAIN)
476 rc = 0;
477
478 return rc;
479}
480
481int
482CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
483{
484 struct smb_hdr *smb_buffer_response;
485 LOGOFF_ANDX_REQ *pSMB;
486 int rc = 0;
487 int length;
488
489 cFYI(1, ("In SMBLogoff for session disconnect"));
490 if (ses)
491 down(&ses->sesSem);
492 else
493 return -EIO;
494
495 atomic_dec(&ses->inUse);
496 if (atomic_read(&ses->inUse) > 0) {
497 up(&ses->sesSem);
498 return -EBUSY;
499 }
500 rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
501 if (rc) {
502 up(&ses->sesSem);
503 return rc;
504 }
505
506 smb_buffer_response = (struct smb_hdr *)pSMB; /* BB removeme BB */
507
508 if(ses->server) {
509 if(ses->server->secMode &
510 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
511 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
512 }
513
514 pSMB->hdr.Uid = ses->Suid;
515
516 pSMB->AndXCommand = 0xFF;
517 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
518 smb_buffer_response, &length, 0);
519 if (ses->server) {
520 atomic_dec(&ses->server->socketUseCount);
521 if (atomic_read(&ses->server->socketUseCount) == 0) {
522 spin_lock(&GlobalMid_Lock);
523 ses->server->tcpStatus = CifsExiting;
524 spin_unlock(&GlobalMid_Lock);
525 rc = -ESHUTDOWN;
526 }
527 }
528 if (pSMB)
529 cifs_small_buf_release(pSMB);
530 up(&ses->sesSem);
531
532 /* if session dead then we do not need to do ulogoff,
533 since server closed smb session, no sense reporting
534 error */
535 if (rc == -EAGAIN)
536 rc = 0;
537 return rc;
538}
539
540int
541CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon,
542 const char *fileName, const struct nls_table *nls_codepage)
543{
544 DELETE_FILE_REQ *pSMB = NULL;
545 DELETE_FILE_RSP *pSMBr = NULL;
546 int rc = 0;
547 int bytes_returned;
548 int name_len;
549
550DelFileRetry:
551 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
552 (void **) &pSMBr);
553 if (rc)
554 return rc;
555
556 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
557 name_len =
558 cifs_strtoUCS((wchar_t *) pSMB->fileName, fileName, PATH_MAX
559 /* find define for this maxpathcomponent */
560 , nls_codepage);
561 name_len++; /* trailing null */
562 name_len *= 2;
563 } else { /* BB improve the check for buffer overruns BB */
564 name_len = strnlen(fileName, PATH_MAX);
565 name_len++; /* trailing null */
566 strncpy(pSMB->fileName, fileName, name_len);
567 }
568 pSMB->SearchAttributes =
569 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
570 pSMB->BufferFormat = 0x04;
571 pSMB->hdr.smb_buf_length += name_len + 1;
572 pSMB->ByteCount = cpu_to_le16(name_len + 1);
573 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
574 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
575 if (rc) {
576 cFYI(1, ("Error in RMFile = %d", rc));
577 }
578#ifdef CONFIG_CIFS_STATS
579 else {
580 atomic_inc(&tcon->num_deletes);
581 }
582#endif
583
584 cifs_buf_release(pSMB);
585 if (rc == -EAGAIN)
586 goto DelFileRetry;
587
588 return rc;
589}
590
591int
592CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon,
593 const char *dirName, const struct nls_table *nls_codepage)
594{
595 DELETE_DIRECTORY_REQ *pSMB = NULL;
596 DELETE_DIRECTORY_RSP *pSMBr = NULL;
597 int rc = 0;
598 int bytes_returned;
599 int name_len;
600
601 cFYI(1, ("In CIFSSMBRmDir"));
602RmDirRetry:
603 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
604 (void **) &pSMBr);
605 if (rc)
606 return rc;
607
608 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
609 name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, dirName, PATH_MAX
610 /* find define for this maxpathcomponent */
611 , nls_codepage);
612 name_len++; /* trailing null */
613 name_len *= 2;
614 } else { /* BB improve the check for buffer overruns BB */
615 name_len = strnlen(dirName, PATH_MAX);
616 name_len++; /* trailing null */
617 strncpy(pSMB->DirName, dirName, name_len);
618 }
619
620 pSMB->BufferFormat = 0x04;
621 pSMB->hdr.smb_buf_length += name_len + 1;
622 pSMB->ByteCount = cpu_to_le16(name_len + 1);
623 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
624 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
625 if (rc) {
626 cFYI(1, ("Error in RMDir = %d", rc));
627 }
628#ifdef CONFIG_CIFS_STATS
629 else {
630 atomic_inc(&tcon->num_rmdirs);
631 }
632#endif
633
634 cifs_buf_release(pSMB);
635 if (rc == -EAGAIN)
636 goto RmDirRetry;
637 return rc;
638}
639
640int
641CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
642 const char *name, const struct nls_table *nls_codepage)
643{
644 int rc = 0;
645 CREATE_DIRECTORY_REQ *pSMB = NULL;
646 CREATE_DIRECTORY_RSP *pSMBr = NULL;
647 int bytes_returned;
648 int name_len;
649
650 cFYI(1, ("In CIFSSMBMkDir"));
651MkDirRetry:
652 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
653 (void **) &pSMBr);
654 if (rc)
655 return rc;
656
657 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
658 name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, name, PATH_MAX
659 /* find define for this maxpathcomponent */
660 , nls_codepage);
661 name_len++; /* trailing null */
662 name_len *= 2;
663 } else { /* BB improve the check for buffer overruns BB */
664 name_len = strnlen(name, PATH_MAX);
665 name_len++; /* trailing null */
666 strncpy(pSMB->DirName, name, name_len);
667 }
668
669 pSMB->BufferFormat = 0x04;
670 pSMB->hdr.smb_buf_length += name_len + 1;
671 pSMB->ByteCount = cpu_to_le16(name_len + 1);
672 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
673 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
674 if (rc) {
675 cFYI(1, ("Error in Mkdir = %d", rc));
676 }
677#ifdef CONFIG_CIFS_STATS
678 else {
679 atomic_inc(&tcon->num_mkdirs);
680 }
681#endif
682 cifs_buf_release(pSMB);
683 if (rc == -EAGAIN)
684 goto MkDirRetry;
685 return rc;
686}
687
688int
689CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
690 const char *fileName, const int openDisposition,
691 const int access_flags, const int create_options, __u16 * netfid,
692 int *pOplock, FILE_ALL_INFO * pfile_info,
693 const struct nls_table *nls_codepage)
694{
695 int rc = -EACCES;
696 OPEN_REQ *pSMB = NULL;
697 OPEN_RSP *pSMBr = NULL;
698 int bytes_returned;
699 int name_len;
700 __u16 count;
701
702openRetry:
703 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
704 (void **) &pSMBr);
705 if (rc)
706 return rc;
707
708 pSMB->AndXCommand = 0xFF; /* none */
709
710 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
711 count = 1; /* account for one byte pad to word boundary */
712 name_len =
713 cifs_strtoUCS((wchar_t *) (pSMB->fileName + 1),
714 fileName, PATH_MAX
715 /* find define for this maxpathcomponent */
716 , nls_codepage);
717 name_len++; /* trailing null */
718 name_len *= 2;
719 pSMB->NameLength = cpu_to_le16(name_len);
720 } else { /* BB improve the check for buffer overruns BB */
721 count = 0; /* no pad */
722 name_len = strnlen(fileName, PATH_MAX);
723 name_len++; /* trailing null */
724 pSMB->NameLength = cpu_to_le16(name_len);
725 strncpy(pSMB->fileName, fileName, name_len);
726 }
727 if (*pOplock & REQ_OPLOCK)
728 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
729 else if (*pOplock & REQ_BATCHOPLOCK) {
730 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
731 }
732 pSMB->DesiredAccess = cpu_to_le32(access_flags);
733 pSMB->AllocationSize = 0;
734 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
735 /* XP does not handle ATTR_POSIX_SEMANTICS */
736 /* but it helps speed up case sensitive checks for other
737 servers such as Samba */
738 if (tcon->ses->capabilities & CAP_UNIX)
739 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
740
741 /* if ((omode & S_IWUGO) == 0)
742 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
743 /* Above line causes problems due to vfs splitting create into two
744 pieces - need to set mode after file created not while it is
745 being created */
746 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
747 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
748 pSMB->CreateOptions = cpu_to_le32(create_options);
749 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION); /* BB ??*/
750 pSMB->SecurityFlags =
751 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
752
753 count += name_len;
754 pSMB->hdr.smb_buf_length += count;
755
756 pSMB->ByteCount = cpu_to_le16(count);
757 /* long_op set to 1 to allow for oplock break timeouts */
758 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
759 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
760 if (rc) {
761 cFYI(1, ("Error in Open = %d", rc));
762 } else {
763 *pOplock = pSMBr->OplockLevel; /* one byte no need to le_to_cpu */
764 *netfid = pSMBr->Fid; /* cifs fid stays in le */
765 /* Let caller know file was created so we can set the mode. */
766 /* Do we care about the CreateAction in any other cases? */
767 if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
768 *pOplock |= CIFS_CREATE_ACTION;
769 if(pfile_info) {
770 memcpy((char *)pfile_info,(char *)&pSMBr->CreationTime,
771 36 /* CreationTime to Attributes */);
772 /* the file_info buf is endian converted by caller */
773 pfile_info->AllocationSize = pSMBr->AllocationSize;
774 pfile_info->EndOfFile = pSMBr->EndOfFile;
775 pfile_info->NumberOfLinks = cpu_to_le32(1);
776 }
777
778#ifdef CONFIG_CIFS_STATS
779 atomic_inc(&tcon->num_opens);
780#endif
781 }
782 cifs_buf_release(pSMB);
783 if (rc == -EAGAIN)
784 goto openRetry;
785 return rc;
786}
787
788/* If no buffer passed in, then caller wants to do the copy
789 as in the case of readpages so the SMB buffer must be
790 freed by the caller */
791
792int
793CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
794 const int netfid, const unsigned int count,
795 const __u64 lseek, unsigned int *nbytes, char **buf)
796{
797 int rc = -EACCES;
798 READ_REQ *pSMB = NULL;
799 READ_RSP *pSMBr = NULL;
800 char *pReadData = NULL;
801 int bytes_returned;
802
803 cFYI(1,("Reading %d bytes on fid %d",count,netfid));
804
805 *nbytes = 0;
806 rc = smb_init(SMB_COM_READ_ANDX, 12, tcon, (void **) &pSMB,
807 (void **) &pSMBr);
808 if (rc)
809 return rc;
810
811 /* tcon and ses pointer are checked in smb_init */
812 if (tcon->ses->server == NULL)
813 return -ECONNABORTED;
814
815 pSMB->AndXCommand = 0xFF; /* none */
816 pSMB->Fid = netfid;
817 pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
818 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
819 pSMB->Remaining = 0;
820 pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
821 pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
822 pSMB->ByteCount = 0; /* no need to do le conversion since it is 0 */
823
824 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
825 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
826 if (rc) {
827 cERROR(1, ("Send error in read = %d", rc));
828 } else {
829 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
830 data_length = data_length << 16;
831 data_length += le16_to_cpu(pSMBr->DataLength);
832 *nbytes = data_length;
833
834 /*check that DataLength would not go beyond end of SMB */
835 if ((data_length > CIFSMaxBufSize)
836 || (data_length > count)) {
837 cFYI(1,("bad length %d for count %d",data_length,count));
838 rc = -EIO;
839 *nbytes = 0;
840 } else {
841 pReadData =
842 (char *) (&pSMBr->hdr.Protocol) +
843 le16_to_cpu(pSMBr->DataOffset);
844/* if(rc = copy_to_user(buf, pReadData, data_length)) {
845 cERROR(1,("Faulting on read rc = %d",rc));
846 rc = -EFAULT;
847 }*/ /* can not use copy_to_user when using page cache*/
848 if(*buf)
849 memcpy(*buf,pReadData,data_length);
850 }
851 }
852 if(*buf)
853 cifs_buf_release(pSMB);
854 else
855 *buf = (char *)pSMB;
856
857 /* Note: On -EAGAIN error only caller can retry on handle based calls
858 since file handle passed in no longer valid */
859 return rc;
860}
861
862int
863CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
864 const int netfid, const unsigned int count,
865 const __u64 offset, unsigned int *nbytes, const char *buf,
866 const char __user * ubuf, const int long_op)
867{
868 int rc = -EACCES;
869 WRITE_REQ *pSMB = NULL;
870 WRITE_RSP *pSMBr = NULL;
871 int bytes_returned;
872 __u32 bytes_sent;
873 __u16 byte_count;
874
875 /* cFYI(1,("write at %lld %d bytes",offset,count));*/
876 rc = smb_init(SMB_COM_WRITE_ANDX, 14, tcon, (void **) &pSMB,
877 (void **) &pSMBr);
878 if (rc)
879 return rc;
880 /* tcon and ses pointer are checked in smb_init */
881 if (tcon->ses->server == NULL)
882 return -ECONNABORTED;
883
884 pSMB->AndXCommand = 0xFF; /* none */
885 pSMB->Fid = netfid;
886 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
887 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
888 pSMB->Reserved = 0xFFFFFFFF;
889 pSMB->WriteMode = 0;
890 pSMB->Remaining = 0;
891
892 /* Can increase buffer size if buffer is big enough in some cases - ie we
893 can send more if LARGE_WRITE_X capability returned by the server and if
894 our buffer is big enough or if we convert to iovecs on socket writes
895 and eliminate the copy to the CIFS buffer */
896 if(tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
897 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
898 } else {
899 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
900 & ~0xFF;
901 }
902
903 if (bytes_sent > count)
904 bytes_sent = count;
905 pSMB->DataOffset =
906 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
907 if(buf)
908 memcpy(pSMB->Data,buf,bytes_sent);
909 else if(ubuf) {
910 if(copy_from_user(pSMB->Data,ubuf,bytes_sent)) {
911 cifs_buf_release(pSMB);
912 return -EFAULT;
913 }
914 } else {
915 /* No buffer */
916 cifs_buf_release(pSMB);
917 return -EINVAL;
918 }
919
920 byte_count = bytes_sent + 1 /* pad */ ; /* BB fix this for sends > 64K */
921 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
922 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
923 pSMB->hdr.smb_buf_length += bytes_sent+1;
924 pSMB->ByteCount = cpu_to_le16(byte_count);
925
926 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
927 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
928 if (rc) {
929 cFYI(1, ("Send error in write = %d", rc));
930 *nbytes = 0;
931 } else {
932 *nbytes = le16_to_cpu(pSMBr->CountHigh);
933 *nbytes = (*nbytes) << 16;
934 *nbytes += le16_to_cpu(pSMBr->Count);
935 }
936
937 cifs_buf_release(pSMB);
938
939 /* Note: On -EAGAIN error only caller can retry on handle based calls
940 since file handle passed in no longer valid */
941
942 return rc;
943}
944
945#ifdef CONFIG_CIFS_EXPERIMENTAL
946int CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
947 const int netfid, const unsigned int count,
948 const __u64 offset, unsigned int *nbytes, const char __user *buf,
949 const int long_op)
950{
951 int rc = -EACCES;
952 WRITE_REQ *pSMB = NULL;
953 WRITE_RSP *pSMBr = NULL;
954 /*int bytes_returned;*/
955 unsigned bytes_sent;
956 __u16 byte_count;
957
958 rc = small_smb_init(SMB_COM_WRITE_ANDX, 14, tcon, (void **) &pSMB);
959
960 if (rc)
961 return rc;
962
963 pSMBr = (WRITE_RSP *)pSMB; /* BB removeme BB */
964
965 /* tcon and ses pointer are checked in smb_init */
966 if (tcon->ses->server == NULL)
967 return -ECONNABORTED;
968
969 pSMB->AndXCommand = 0xFF; /* none */
970 pSMB->Fid = netfid;
971 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
972 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
973 pSMB->Reserved = 0xFFFFFFFF;
974 pSMB->WriteMode = 0;
975 pSMB->Remaining = 0;
976 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & ~0xFF;
977 if (bytes_sent > count)
978 bytes_sent = count;
979 pSMB->DataLengthHigh = 0;
980 pSMB->DataOffset =
981 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
982
983 byte_count = bytes_sent + 1 /* pad */ ;
984 pSMB->DataLengthLow = cpu_to_le16(bytes_sent);
985 pSMB->DataLengthHigh = 0;
986 pSMB->hdr.smb_buf_length += byte_count;
987 pSMB->ByteCount = cpu_to_le16(byte_count);
988
989/* rc = SendReceive2(xid, tcon->ses, (struct smb_hdr *) pSMB,
990 (struct smb_hdr *) pSMBr, buf, buflen, &bytes_returned, long_op); */ /* BB fixme BB */
991 if (rc) {
992 cFYI(1, ("Send error in write2 (large write) = %d", rc));
993 *nbytes = 0;
994 } else
995 *nbytes = le16_to_cpu(pSMBr->Count);
996
997 cifs_small_buf_release(pSMB);
998
999 /* Note: On -EAGAIN error only caller can retry on handle based calls
1000 since file handle passed in no longer valid */
1001
1002 return rc;
1003}
1004#endif /* CIFS_EXPERIMENTAL */
1005
1006int
1007CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1008 const __u16 smb_file_id, const __u64 len,
1009 const __u64 offset, const __u32 numUnlock,
1010 const __u32 numLock, const __u8 lockType, const int waitFlag)
1011{
1012 int rc = 0;
1013 LOCK_REQ *pSMB = NULL;
1014 LOCK_RSP *pSMBr = NULL;
1015 int bytes_returned;
1016 int timeout = 0;
1017 __u16 count;
1018
1019 cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
1020 rc = smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB,
1021 (void **) &pSMBr);
1022 if (rc)
1023 return rc;
1024
1025 if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1026 timeout = -1; /* no response expected */
1027 pSMB->Timeout = 0;
1028 } else if (waitFlag == TRUE) {
1029 timeout = 3; /* blocking operation, no timeout */
1030 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1031 } else {
1032 pSMB->Timeout = 0;
1033 }
1034
1035 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1036 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1037 pSMB->LockType = lockType;
1038 pSMB->AndXCommand = 0xFF; /* none */
1039 pSMB->Fid = smb_file_id; /* netfid stays le */
1040
1041 if((numLock != 0) || (numUnlock != 0)) {
1042 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1043 /* BB where to store pid high? */
1044 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1045 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1046 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1047 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1048 count = sizeof(LOCKING_ANDX_RANGE);
1049 } else {
1050 /* oplock break */
1051 count = 0;
1052 }
1053 pSMB->hdr.smb_buf_length += count;
1054 pSMB->ByteCount = cpu_to_le16(count);
1055
1056 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1057 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1058
1059 if (rc) {
1060 cFYI(1, ("Send error in Lock = %d", rc));
1061 }
1062 cifs_buf_release(pSMB);
1063
1064 /* Note: On -EAGAIN error only caller can retry on handle based calls
1065 since file handle passed in no longer valid */
1066 return rc;
1067}
1068
1069int
1070CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1071{
1072 int rc = 0;
1073 CLOSE_REQ *pSMB = NULL;
1074 CLOSE_RSP *pSMBr = NULL;
1075 int bytes_returned;
1076 cFYI(1, ("In CIFSSMBClose"));
1077
1078/* do not retry on dead session on close */
1079 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1080 if(rc == -EAGAIN)
1081 return 0;
1082 if (rc)
1083 return rc;
1084
1085 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
1086
1087 pSMB->FileID = (__u16) smb_file_id;
1088 pSMB->LastWriteTime = 0;
1089 pSMB->ByteCount = 0;
1090 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1091 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1092 if (rc) {
1093 if(rc!=-EINTR) {
1094 /* EINTR is expected when user ctl-c to kill app */
1095 cERROR(1, ("Send error in Close = %d", rc));
1096 }
1097 }
1098
1099 cifs_small_buf_release(pSMB);
1100
1101 /* Since session is dead, file will be closed on server already */
1102 if(rc == -EAGAIN)
1103 rc = 0;
1104
1105 return rc;
1106}
1107
1108int
1109CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1110 const char *fromName, const char *toName,
1111 const struct nls_table *nls_codepage)
1112{
1113 int rc = 0;
1114 RENAME_REQ *pSMB = NULL;
1115 RENAME_RSP *pSMBr = NULL;
1116 int bytes_returned;
1117 int name_len, name_len2;
1118 __u16 count;
1119
1120 cFYI(1, ("In CIFSSMBRename"));
1121renameRetry:
1122 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1123 (void **) &pSMBr);
1124 if (rc)
1125 return rc;
1126
1127 pSMB->BufferFormat = 0x04;
1128 pSMB->SearchAttributes =
1129 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1130 ATTR_DIRECTORY);
1131
1132 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1133 name_len =
1134 cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, PATH_MAX
1135 /* find define for this maxpathcomponent */
1136 , nls_codepage);
1137 name_len++; /* trailing null */
1138 name_len *= 2;
1139 pSMB->OldFileName[name_len] = 0x04; /* pad */
1140 /* protocol requires ASCII signature byte on Unicode string */
1141 pSMB->OldFileName[name_len + 1] = 0x00;
1142 name_len2 =
1143 cifs_strtoUCS((wchar_t *) & pSMB->
1144 OldFileName[name_len + 2], toName, PATH_MAX,
1145 nls_codepage);
1146 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1147 name_len2 *= 2; /* convert to bytes */
1148 } else { /* BB improve the check for buffer overruns BB */
1149 name_len = strnlen(fromName, PATH_MAX);
1150 name_len++; /* trailing null */
1151 strncpy(pSMB->OldFileName, fromName, name_len);
1152 name_len2 = strnlen(toName, PATH_MAX);
1153 name_len2++; /* trailing null */
1154 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1155 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1156 name_len2++; /* trailing null */
1157 name_len2++; /* signature byte */
1158 }
1159
1160 count = 1 /* 1st signature byte */ + name_len + name_len2;
1161 pSMB->hdr.smb_buf_length += count;
1162 pSMB->ByteCount = cpu_to_le16(count);
1163
1164 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1165 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1166 if (rc) {
1167 cFYI(1, ("Send error in rename = %d", rc));
1168 }
1169
1170#ifdef CONFIG_CIFS_STATS
1171 else {
1172 atomic_inc(&tcon->num_renames);
1173 }
1174#endif
1175
1176 cifs_buf_release(pSMB);
1177
1178 if (rc == -EAGAIN)
1179 goto renameRetry;
1180
1181 return rc;
1182}
1183
1184int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
1185 int netfid, char * target_name, const struct nls_table * nls_codepage)
1186{
1187 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1188 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1189 struct set_file_rename * rename_info;
1190 char *data_offset;
1191 char dummy_string[30];
1192 int rc = 0;
1193 int bytes_returned = 0;
1194 int len_of_str;
1195 __u16 params, param_offset, offset, count, byte_count;
1196
1197 cFYI(1, ("Rename to File by handle"));
1198 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
1199 (void **) &pSMBr);
1200 if (rc)
1201 return rc;
1202
1203 params = 6;
1204 pSMB->MaxSetupCount = 0;
1205 pSMB->Reserved = 0;
1206 pSMB->Flags = 0;
1207 pSMB->Timeout = 0;
1208 pSMB->Reserved2 = 0;
1209 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1210 offset = param_offset + params;
1211
1212 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1213 rename_info = (struct set_file_rename *) data_offset;
1214 pSMB->MaxParameterCount = cpu_to_le16(2);
1215 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1216 pSMB->SetupCount = 1;
1217 pSMB->Reserved3 = 0;
1218 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1219 byte_count = 3 /* pad */ + params;
1220 pSMB->ParameterCount = cpu_to_le16(params);
1221 pSMB->TotalParameterCount = pSMB->ParameterCount;
1222 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1223 pSMB->DataOffset = cpu_to_le16(offset);
1224 /* construct random name ".cifs_tmp<inodenum><mid>" */
1225 rename_info->overwrite = cpu_to_le32(1);
1226 rename_info->root_fid = 0;
1227 /* unicode only call */
1228 if(target_name == NULL) {
1229 sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
1230 len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, dummy_string, 24, nls_codepage);
1231 } else {
1232 len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, target_name, PATH_MAX, nls_codepage);
1233 }
1234 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
1235 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
1236 byte_count += count;
1237 pSMB->DataCount = cpu_to_le16(count);
1238 pSMB->TotalDataCount = pSMB->DataCount;
1239 pSMB->Fid = netfid;
1240 pSMB->InformationLevel =
1241 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
1242 pSMB->Reserved4 = 0;
1243 pSMB->hdr.smb_buf_length += byte_count;
1244 pSMB->ByteCount = cpu_to_le16(byte_count);
1245 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
1246 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1247 if (rc) {
1248 cFYI(1,("Send error in Rename (by file handle) = %d", rc));
1249 }
1250#ifdef CONFIG_CIFS_STATS
1251 else {
1252 atomic_inc(&pTcon->num_t2renames);
1253 }
1254#endif
1255 cifs_buf_release(pSMB);
1256
1257 /* Note: On -EAGAIN error only caller can retry on handle based calls
1258 since file handle passed in no longer valid */
1259
1260 return rc;
1261}
1262
1263int
1264CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName,
1265 const __u16 target_tid, const char *toName, const int flags,
1266 const struct nls_table *nls_codepage)
1267{
1268 int rc = 0;
1269 COPY_REQ *pSMB = NULL;
1270 COPY_RSP *pSMBr = NULL;
1271 int bytes_returned;
1272 int name_len, name_len2;
1273 __u16 count;
1274
1275 cFYI(1, ("In CIFSSMBCopy"));
1276copyRetry:
1277 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
1278 (void **) &pSMBr);
1279 if (rc)
1280 return rc;
1281
1282 pSMB->BufferFormat = 0x04;
1283 pSMB->Tid2 = target_tid;
1284
1285 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
1286
1287 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1288 name_len = cifs_strtoUCS((wchar_t *) pSMB->OldFileName,
1289 fromName,
1290 PATH_MAX /* find define for this maxpathcomponent */,
1291 nls_codepage);
1292 name_len++; /* trailing null */
1293 name_len *= 2;
1294 pSMB->OldFileName[name_len] = 0x04; /* pad */
1295 /* protocol requires ASCII signature byte on Unicode string */
1296 pSMB->OldFileName[name_len + 1] = 0x00;
1297 name_len2 = cifs_strtoUCS((wchar_t *) & pSMB->
1298 OldFileName[name_len + 2], toName, PATH_MAX,
1299 nls_codepage);
1300 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1301 name_len2 *= 2; /* convert to bytes */
1302 } else { /* BB improve the check for buffer overruns BB */
1303 name_len = strnlen(fromName, PATH_MAX);
1304 name_len++; /* trailing null */
1305 strncpy(pSMB->OldFileName, fromName, name_len);
1306 name_len2 = strnlen(toName, PATH_MAX);
1307 name_len2++; /* trailing null */
1308 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1309 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1310 name_len2++; /* trailing null */
1311 name_len2++; /* signature byte */
1312 }
1313
1314 count = 1 /* 1st signature byte */ + name_len + name_len2;
1315 pSMB->hdr.smb_buf_length += count;
1316 pSMB->ByteCount = cpu_to_le16(count);
1317
1318 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1319 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1320 if (rc) {
1321 cFYI(1, ("Send error in copy = %d with %d files copied",
1322 rc, le16_to_cpu(pSMBr->CopyCount)));
1323 }
1324 if (pSMB)
1325 cifs_buf_release(pSMB);
1326
1327 if (rc == -EAGAIN)
1328 goto copyRetry;
1329
1330 return rc;
1331}
1332
1333int
1334CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
1335 const char *fromName, const char *toName,
1336 const struct nls_table *nls_codepage)
1337{
1338 TRANSACTION2_SPI_REQ *pSMB = NULL;
1339 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1340 char *data_offset;
1341 int name_len;
1342 int name_len_target;
1343 int rc = 0;
1344 int bytes_returned = 0;
1345 __u16 params, param_offset, offset, byte_count;
1346
1347 cFYI(1, ("In Symlink Unix style"));
1348createSymLinkRetry:
1349 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1350 (void **) &pSMBr);
1351 if (rc)
1352 return rc;
1353
1354 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1355 name_len =
1356 cifs_strtoUCS((wchar_t *) pSMB->FileName, fromName, PATH_MAX
1357 /* find define for this maxpathcomponent */
1358 , nls_codepage);
1359 name_len++; /* trailing null */
1360 name_len *= 2;
1361
1362 } else { /* BB improve the check for buffer overruns BB */
1363 name_len = strnlen(fromName, PATH_MAX);
1364 name_len++; /* trailing null */
1365 strncpy(pSMB->FileName, fromName, name_len);
1366 }
1367 params = 6 + name_len;
1368 pSMB->MaxSetupCount = 0;
1369 pSMB->Reserved = 0;
1370 pSMB->Flags = 0;
1371 pSMB->Timeout = 0;
1372 pSMB->Reserved2 = 0;
1373 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1374 InformationLevel) - 4;
1375 offset = param_offset + params;
1376
1377 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1378 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1379 name_len_target =
1380 cifs_strtoUCS((wchar_t *) data_offset, toName, PATH_MAX
1381 /* find define for this maxpathcomponent */
1382 , nls_codepage);
1383 name_len_target++; /* trailing null */
1384 name_len_target *= 2;
1385 } else { /* BB improve the check for buffer overruns BB */
1386 name_len_target = strnlen(toName, PATH_MAX);
1387 name_len_target++; /* trailing null */
1388 strncpy(data_offset, toName, name_len_target);
1389 }
1390
1391 pSMB->MaxParameterCount = cpu_to_le16(2);
1392 /* BB find exact max on data count below from sess */
1393 pSMB->MaxDataCount = cpu_to_le16(1000);
1394 pSMB->SetupCount = 1;
1395 pSMB->Reserved3 = 0;
1396 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1397 byte_count = 3 /* pad */ + params + name_len_target;
1398 pSMB->DataCount = cpu_to_le16(name_len_target);
1399 pSMB->ParameterCount = cpu_to_le16(params);
1400 pSMB->TotalDataCount = pSMB->DataCount;
1401 pSMB->TotalParameterCount = pSMB->ParameterCount;
1402 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1403 pSMB->DataOffset = cpu_to_le16(offset);
1404 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
1405 pSMB->Reserved4 = 0;
1406 pSMB->hdr.smb_buf_length += byte_count;
1407 pSMB->ByteCount = cpu_to_le16(byte_count);
1408 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1409 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1410 if (rc) {
1411 cFYI(1,
1412 ("Send error in SetPathInfo (create symlink) = %d",
1413 rc));
1414 }
1415
1416 if (pSMB)
1417 cifs_buf_release(pSMB);
1418
1419 if (rc == -EAGAIN)
1420 goto createSymLinkRetry;
1421
1422 return rc;
1423}
1424
1425int
1426CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1427 const char *fromName, const char *toName,
1428 const struct nls_table *nls_codepage)
1429{
1430 TRANSACTION2_SPI_REQ *pSMB = NULL;
1431 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1432 char *data_offset;
1433 int name_len;
1434 int name_len_target;
1435 int rc = 0;
1436 int bytes_returned = 0;
1437 __u16 params, param_offset, offset, byte_count;
1438
1439 cFYI(1, ("In Create Hard link Unix style"));
1440createHardLinkRetry:
1441 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1442 (void **) &pSMBr);
1443 if (rc)
1444 return rc;
1445
1446 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1447 name_len = cifs_strtoUCS((wchar_t *) pSMB->FileName, toName, PATH_MAX
1448 /* find define for this maxpathcomponent */
1449 , nls_codepage);
1450 name_len++; /* trailing null */
1451 name_len *= 2;
1452
1453 } else { /* BB improve the check for buffer overruns BB */
1454 name_len = strnlen(toName, PATH_MAX);
1455 name_len++; /* trailing null */
1456 strncpy(pSMB->FileName, toName, name_len);
1457 }
1458 params = 6 + name_len;
1459 pSMB->MaxSetupCount = 0;
1460 pSMB->Reserved = 0;
1461 pSMB->Flags = 0;
1462 pSMB->Timeout = 0;
1463 pSMB->Reserved2 = 0;
1464 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1465 InformationLevel) - 4;
1466 offset = param_offset + params;
1467
1468 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1469 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1470 name_len_target =
1471 cifs_strtoUCS((wchar_t *) data_offset, fromName, PATH_MAX
1472 /* find define for this maxpathcomponent */
1473 , nls_codepage);
1474 name_len_target++; /* trailing null */
1475 name_len_target *= 2;
1476 } else { /* BB improve the check for buffer overruns BB */
1477 name_len_target = strnlen(fromName, PATH_MAX);
1478 name_len_target++; /* trailing null */
1479 strncpy(data_offset, fromName, name_len_target);
1480 }
1481
1482 pSMB->MaxParameterCount = cpu_to_le16(2);
1483 /* BB find exact max on data count below from sess*/
1484 pSMB->MaxDataCount = cpu_to_le16(1000);
1485 pSMB->SetupCount = 1;
1486 pSMB->Reserved3 = 0;
1487 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1488 byte_count = 3 /* pad */ + params + name_len_target;
1489 pSMB->ParameterCount = cpu_to_le16(params);
1490 pSMB->TotalParameterCount = pSMB->ParameterCount;
1491 pSMB->DataCount = cpu_to_le16(name_len_target);
1492 pSMB->TotalDataCount = pSMB->DataCount;
1493 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1494 pSMB->DataOffset = cpu_to_le16(offset);
1495 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
1496 pSMB->Reserved4 = 0;
1497 pSMB->hdr.smb_buf_length += byte_count;
1498 pSMB->ByteCount = cpu_to_le16(byte_count);
1499 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1500 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1501 if (rc) {
1502 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
1503 }
1504
1505 cifs_buf_release(pSMB);
1506 if (rc == -EAGAIN)
1507 goto createHardLinkRetry;
1508
1509 return rc;
1510}
1511
1512int
1513CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1514 const char *fromName, const char *toName,
1515 const struct nls_table *nls_codepage)
1516{
1517 int rc = 0;
1518 NT_RENAME_REQ *pSMB = NULL;
1519 RENAME_RSP *pSMBr = NULL;
1520 int bytes_returned;
1521 int name_len, name_len2;
1522 __u16 count;
1523
1524 cFYI(1, ("In CIFSCreateHardLink"));
1525winCreateHardLinkRetry:
1526
1527 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
1528 (void **) &pSMBr);
1529 if (rc)
1530 return rc;
1531
1532 pSMB->SearchAttributes =
1533 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1534 ATTR_DIRECTORY);
1535 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
1536 pSMB->ClusterCount = 0;
1537
1538 pSMB->BufferFormat = 0x04;
1539
1540 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1541 name_len =
1542 cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, PATH_MAX
1543 /* find define for this maxpathcomponent */
1544 , nls_codepage);
1545 name_len++; /* trailing null */
1546 name_len *= 2;
1547 pSMB->OldFileName[name_len] = 0; /* pad */
1548 pSMB->OldFileName[name_len + 1] = 0x04;
1549 name_len2 =
1550 cifs_strtoUCS((wchar_t *) & pSMB->
1551 OldFileName[name_len + 2], toName, PATH_MAX,
1552 nls_codepage);
1553 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1554 name_len2 *= 2; /* convert to bytes */
1555 } else { /* BB improve the check for buffer overruns BB */
1556 name_len = strnlen(fromName, PATH_MAX);
1557 name_len++; /* trailing null */
1558 strncpy(pSMB->OldFileName, fromName, name_len);
1559 name_len2 = strnlen(toName, PATH_MAX);
1560 name_len2++; /* trailing null */
1561 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1562 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1563 name_len2++; /* trailing null */
1564 name_len2++; /* signature byte */
1565 }
1566
1567 count = 1 /* string type byte */ + name_len + name_len2;
1568 pSMB->hdr.smb_buf_length += count;
1569 pSMB->ByteCount = cpu_to_le16(count);
1570
1571 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1572 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1573 if (rc) {
1574 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
1575 }
1576 cifs_buf_release(pSMB);
1577 if (rc == -EAGAIN)
1578 goto winCreateHardLinkRetry;
1579
1580 return rc;
1581}
1582
1583int
1584CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
1585 const unsigned char *searchName,
1586 char *symlinkinfo, const int buflen,
1587 const struct nls_table *nls_codepage)
1588{
1589/* SMB_QUERY_FILE_UNIX_LINK */
1590 TRANSACTION2_QPI_REQ *pSMB = NULL;
1591 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1592 int rc = 0;
1593 int bytes_returned;
1594 int name_len;
1595 __u16 params, byte_count;
1596
1597 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
1598
1599querySymLinkRetry:
1600 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1601 (void **) &pSMBr);
1602 if (rc)
1603 return rc;
1604
1605 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1606 name_len =
1607 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
1608 /* find define for this maxpathcomponent */
1609 , nls_codepage);
1610 name_len++; /* trailing null */
1611 name_len *= 2;
1612 } else { /* BB improve the check for buffer overruns BB */
1613 name_len = strnlen(searchName, PATH_MAX);
1614 name_len++; /* trailing null */
1615 strncpy(pSMB->FileName, searchName, name_len);
1616 }
1617
1618 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1619 pSMB->TotalDataCount = 0;
1620 pSMB->MaxParameterCount = cpu_to_le16(2);
1621 /* BB find exact max data count below from sess structure BB */
1622 pSMB->MaxDataCount = cpu_to_le16(4000);
1623 pSMB->MaxSetupCount = 0;
1624 pSMB->Reserved = 0;
1625 pSMB->Flags = 0;
1626 pSMB->Timeout = 0;
1627 pSMB->Reserved2 = 0;
1628 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1629 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1630 pSMB->DataCount = 0;
1631 pSMB->DataOffset = 0;
1632 pSMB->SetupCount = 1;
1633 pSMB->Reserved3 = 0;
1634 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1635 byte_count = params + 1 /* pad */ ;
1636 pSMB->TotalParameterCount = cpu_to_le16(params);
1637 pSMB->ParameterCount = pSMB->TotalParameterCount;
1638 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
1639 pSMB->Reserved4 = 0;
1640 pSMB->hdr.smb_buf_length += byte_count;
1641 pSMB->ByteCount = cpu_to_le16(byte_count);
1642
1643 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1644 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1645 if (rc) {
1646 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
1647 } else {
1648 /* decode response */
1649
1650 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1651 if (rc || (pSMBr->ByteCount < 2))
1652 /* BB also check enough total bytes returned */
1653 rc = -EIO; /* bad smb */
1654 else {
1655 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1656 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
1657
1658 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1659 name_len = UniStrnlen((wchar_t *) ((char *)
1660 &pSMBr->hdr.Protocol +data_offset),
1661 min_t(const int, buflen,count) / 2);
1662 cifs_strfromUCS_le(symlinkinfo,
1663 (wchar_t *) ((char *)&pSMBr->hdr.Protocol +
1664 data_offset),
1665 name_len, nls_codepage);
1666 } else {
1667 strncpy(symlinkinfo,
1668 (char *) &pSMBr->hdr.Protocol +
1669 data_offset,
1670 min_t(const int, buflen, count));
1671 }
1672 symlinkinfo[buflen] = 0;
1673 /* just in case so calling code does not go off the end of buffer */
1674 }
1675 }
1676 cifs_buf_release(pSMB);
1677 if (rc == -EAGAIN)
1678 goto querySymLinkRetry;
1679 return rc;
1680}
1681
1682int
1683CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
1684 const unsigned char *searchName,
1685 char *symlinkinfo, const int buflen,__u16 fid,
1686 const struct nls_table *nls_codepage)
1687{
1688 int rc = 0;
1689 int bytes_returned;
1690 int name_len;
1691 struct smb_com_transaction_ioctl_req * pSMB;
1692 struct smb_com_transaction_ioctl_rsp * pSMBr;
1693
1694 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
1695 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
1696 (void **) &pSMBr);
1697 if (rc)
1698 return rc;
1699
1700 pSMB->TotalParameterCount = 0 ;
1701 pSMB->TotalDataCount = 0;
1702 pSMB->MaxParameterCount = cpu_to_le32(2);
1703 /* BB find exact data count max from sess structure BB */
1704 pSMB->MaxDataCount = cpu_to_le32(4000);
1705 pSMB->MaxSetupCount = 4;
1706 pSMB->Reserved = 0;
1707 pSMB->ParameterOffset = 0;
1708 pSMB->DataCount = 0;
1709 pSMB->DataOffset = 0;
1710 pSMB->SetupCount = 4;
1711 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
1712 pSMB->ParameterCount = pSMB->TotalParameterCount;
1713 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
1714 pSMB->IsFsctl = 1; /* FSCTL */
1715 pSMB->IsRootFlag = 0;
1716 pSMB->Fid = fid; /* file handle always le */
1717 pSMB->ByteCount = 0;
1718
1719 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1720 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1721 if (rc) {
1722 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
1723 } else { /* decode response */
1724 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
1725 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
1726 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
1727 /* BB also check enough total bytes returned */
1728 rc = -EIO; /* bad smb */
1729 else {
1730 if(data_count && (data_count < 2048)) {
1731 char * end_of_smb = pSMBr->ByteCount + (char *)&pSMBr->ByteCount;
1732
1733 struct reparse_data * reparse_buf = (struct reparse_data *)
1734 ((char *)&pSMBr->hdr.Protocol + data_offset);
1735 if((char*)reparse_buf >= end_of_smb) {
1736 rc = -EIO;
1737 goto qreparse_out;
1738 }
1739 if((reparse_buf->LinkNamesBuf +
1740 reparse_buf->TargetNameOffset +
1741 reparse_buf->TargetNameLen) >
1742 end_of_smb) {
1743 cFYI(1,("reparse buf extended beyond SMB"));
1744 rc = -EIO;
1745 goto qreparse_out;
1746 }
1747
1748 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1749 name_len = UniStrnlen((wchar_t *)
1750 (reparse_buf->LinkNamesBuf +
1751 reparse_buf->TargetNameOffset),
1752 min(buflen/2, reparse_buf->TargetNameLen / 2));
1753 cifs_strfromUCS_le(symlinkinfo,
1754 (wchar_t *) (reparse_buf->LinkNamesBuf +
1755 reparse_buf->TargetNameOffset),
1756 name_len, nls_codepage);
1757 } else { /* ASCII names */
1758 strncpy(symlinkinfo,reparse_buf->LinkNamesBuf +
1759 reparse_buf->TargetNameOffset,
1760 min_t(const int, buflen, reparse_buf->TargetNameLen));
1761 }
1762 } else {
1763 rc = -EIO;
1764 cFYI(1,("Invalid return data count on get reparse info ioctl"));
1765 }
1766 symlinkinfo[buflen] = 0; /* just in case so the caller
1767 does not go off the end of the buffer */
1768 cFYI(1,("readlink result - %s ",symlinkinfo));
1769 }
1770 }
1771qreparse_out:
1772 if (pSMB)
1773 cifs_buf_release(pSMB);
1774
1775 /* Note: On -EAGAIN error only caller can retry on handle based calls
1776 since file handle passed in no longer valid */
1777
1778 return rc;
1779}
1780
1781#ifdef CONFIG_CIFS_POSIX
1782
1783/*Convert an Access Control Entry from wire format to local POSIX xattr format*/
1784static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace * cifs_ace)
1785{
1786 /* u8 cifs fields do not need le conversion */
1787 ace->e_perm = (__u16)cifs_ace->cifs_e_perm;
1788 ace->e_tag = (__u16)cifs_ace->cifs_e_tag;
1789 ace->e_id = (__u32)le64_to_cpu(cifs_ace->cifs_uid);
1790 /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
1791
1792 return;
1793}
1794
1795/* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
1796static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,const int acl_type,const int size_of_data_area)
1797{
1798 int size = 0;
1799 int i;
1800 __u16 count;
1801 struct cifs_posix_ace * pACE;
1802 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)src;
1803 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)trgt;
1804
1805 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
1806 return -EOPNOTSUPP;
1807
1808 if(acl_type & ACL_TYPE_ACCESS) {
1809 count = le16_to_cpu(cifs_acl->access_entry_count);
1810 pACE = &cifs_acl->ace_array[0];
1811 size = sizeof(struct cifs_posix_acl);
1812 size += sizeof(struct cifs_posix_ace) * count;
1813 /* check if we would go beyond end of SMB */
1814 if(size_of_data_area < size) {
1815 cFYI(1,("bad CIFS POSIX ACL size %d vs. %d",size_of_data_area,size));
1816 return -EINVAL;
1817 }
1818 } else if(acl_type & ACL_TYPE_DEFAULT) {
1819 count = le16_to_cpu(cifs_acl->access_entry_count);
1820 size = sizeof(struct cifs_posix_acl);
1821 size += sizeof(struct cifs_posix_ace) * count;
1822/* skip past access ACEs to get to default ACEs */
1823 pACE = &cifs_acl->ace_array[count];
1824 count = le16_to_cpu(cifs_acl->default_entry_count);
1825 size += sizeof(struct cifs_posix_ace) * count;
1826 /* check if we would go beyond end of SMB */
1827 if(size_of_data_area < size)
1828 return -EINVAL;
1829 } else {
1830 /* illegal type */
1831 return -EINVAL;
1832 }
1833
1834 size = posix_acl_xattr_size(count);
1835 if((buflen == 0) || (local_acl == NULL)) {
1836 /* used to query ACL EA size */
1837 } else if(size > buflen) {
1838 return -ERANGE;
1839 } else /* buffer big enough */ {
1840 local_acl->a_version = POSIX_ACL_XATTR_VERSION;
1841 for(i = 0;i < count ;i++) {
1842 cifs_convert_ace(&local_acl->a_entries[i],pACE);
1843 pACE ++;
1844 }
1845 }
1846 return size;
1847}
1848
1849static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace * cifs_ace,
1850 const posix_acl_xattr_entry * local_ace)
1851{
1852 __u16 rc = 0; /* 0 = ACL converted ok */
1853
1854 cifs_ace->cifs_e_perm = (__u8)cpu_to_le16(local_ace->e_perm);
1855 cifs_ace->cifs_e_tag = (__u8)cpu_to_le16(local_ace->e_tag);
1856 /* BB is there a better way to handle the large uid? */
1857 if(local_ace->e_id == -1) {
1858 /* Probably no need to le convert -1 on any arch but can not hurt */
1859 cifs_ace->cifs_uid = cpu_to_le64(-1);
1860 } else
1861 cifs_ace->cifs_uid = (__u64)cpu_to_le32(local_ace->e_id);
1862 /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
1863 return rc;
1864}
1865
1866/* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
1867static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int buflen,
1868 const int acl_type)
1869{
1870 __u16 rc = 0;
1871 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)parm_data;
1872 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)pACL;
1873 int count;
1874 int i;
1875
1876 if((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
1877 return 0;
1878
1879 count = posix_acl_xattr_count((size_t)buflen);
1880 cFYI(1,("setting acl with %d entries from buf of length %d and version of %d",
1881 count,buflen,local_acl->a_version));
1882 if(local_acl->a_version != 2) {
1883 cFYI(1,("unknown POSIX ACL version %d",local_acl->a_version));
1884 return 0;
1885 }
1886 cifs_acl->version = cpu_to_le16(1);
1887 if(acl_type == ACL_TYPE_ACCESS)
1888 cifs_acl->access_entry_count = count;
1889 else if(acl_type == ACL_TYPE_DEFAULT)
1890 cifs_acl->default_entry_count = count;
1891 else {
1892 cFYI(1,("unknown ACL type %d",acl_type));
1893 return 0;
1894 }
1895 for(i=0;i<count;i++) {
1896 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
1897 &local_acl->a_entries[i]);
1898 if(rc != 0) {
1899 /* ACE not converted */
1900 break;
1901 }
1902 }
1903 if(rc == 0) {
1904 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
1905 rc += sizeof(struct cifs_posix_acl);
1906 /* BB add check to make sure ACL does not overflow SMB */
1907 }
1908 return rc;
1909}
1910
1911int
1912CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
1913 const unsigned char *searchName,
1914 char *acl_inf, const int buflen, const int acl_type,
1915 const struct nls_table *nls_codepage)
1916{
1917/* SMB_QUERY_POSIX_ACL */
1918 TRANSACTION2_QPI_REQ *pSMB = NULL;
1919 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1920 int rc = 0;
1921 int bytes_returned;
1922 int name_len;
1923 __u16 params, byte_count;
1924
1925 cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
1926
1927queryAclRetry:
1928 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1929 (void **) &pSMBr);
1930 if (rc)
1931 return rc;
1932
1933 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1934 name_len =
1935 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
1936 , nls_codepage);
1937 name_len++; /* trailing null */
1938 name_len *= 2;
1939 pSMB->FileName[name_len] = 0;
1940 pSMB->FileName[name_len+1] = 0;
1941 } else { /* BB improve the check for buffer overruns BB */
1942 name_len = strnlen(searchName, PATH_MAX);
1943 name_len++; /* trailing null */
1944 strncpy(pSMB->FileName, searchName, name_len);
1945 }
1946
1947 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1948 pSMB->TotalDataCount = 0;
1949 pSMB->MaxParameterCount = cpu_to_le16(2);
1950 /* BB find exact max data count below from sess structure BB */
1951 pSMB->MaxDataCount = cpu_to_le16(4000);
1952 pSMB->MaxSetupCount = 0;
1953 pSMB->Reserved = 0;
1954 pSMB->Flags = 0;
1955 pSMB->Timeout = 0;
1956 pSMB->Reserved2 = 0;
1957 pSMB->ParameterOffset = cpu_to_le16(
1958 offsetof(struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1959 pSMB->DataCount = 0;
1960 pSMB->DataOffset = 0;
1961 pSMB->SetupCount = 1;
1962 pSMB->Reserved3 = 0;
1963 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1964 byte_count = params + 1 /* pad */ ;
1965 pSMB->TotalParameterCount = cpu_to_le16(params);
1966 pSMB->ParameterCount = pSMB->TotalParameterCount;
1967 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
1968 pSMB->Reserved4 = 0;
1969 pSMB->hdr.smb_buf_length += byte_count;
1970 pSMB->ByteCount = cpu_to_le16(byte_count);
1971
1972 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1973 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1974 if (rc) {
1975 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
1976 } else {
1977 /* decode response */
1978
1979 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1980 if (rc || (pSMBr->ByteCount < 2))
1981 /* BB also check enough total bytes returned */
1982 rc = -EIO; /* bad smb */
1983 else {
1984 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1985 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
1986 rc = cifs_copy_posix_acl(acl_inf,
1987 (char *)&pSMBr->hdr.Protocol+data_offset,
1988 buflen,acl_type,count);
1989 }
1990 }
1991 cifs_buf_release(pSMB);
1992 if (rc == -EAGAIN)
1993 goto queryAclRetry;
1994 return rc;
1995}
1996
1997int
1998CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
1999 const unsigned char *fileName,
2000 const char *local_acl, const int buflen, const int acl_type,
2001 const struct nls_table *nls_codepage)
2002{
2003 struct smb_com_transaction2_spi_req *pSMB = NULL;
2004 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2005 char *parm_data;
2006 int name_len;
2007 int rc = 0;
2008 int bytes_returned = 0;
2009 __u16 params, byte_count, data_count, param_offset, offset;
2010
2011 cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2012setAclRetry:
2013 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2014 (void **) &pSMBr);
2015 if (rc)
2016 return rc;
2017 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2018 name_len =
2019 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
2020 , nls_codepage);
2021 name_len++; /* trailing null */
2022 name_len *= 2;
2023 } else { /* BB improve the check for buffer overruns BB */
2024 name_len = strnlen(fileName, PATH_MAX);
2025 name_len++; /* trailing null */
2026 strncpy(pSMB->FileName, fileName, name_len);
2027 }
2028 params = 6 + name_len;
2029 pSMB->MaxParameterCount = cpu_to_le16(2);
2030 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2031 pSMB->MaxSetupCount = 0;
2032 pSMB->Reserved = 0;
2033 pSMB->Flags = 0;
2034 pSMB->Timeout = 0;
2035 pSMB->Reserved2 = 0;
2036 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2037 InformationLevel) - 4;
2038 offset = param_offset + params;
2039 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2040 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2041
2042 /* convert to on the wire format for POSIX ACL */
2043 data_count = ACL_to_cifs_posix(parm_data,local_acl,buflen,acl_type);
2044
2045 if(data_count == 0) {
2046 rc = -EOPNOTSUPP;
2047 goto setACLerrorExit;
2048 }
2049 pSMB->DataOffset = cpu_to_le16(offset);
2050 pSMB->SetupCount = 1;
2051 pSMB->Reserved3 = 0;
2052 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2053 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2054 byte_count = 3 /* pad */ + params + data_count;
2055 pSMB->DataCount = cpu_to_le16(data_count);
2056 pSMB->TotalDataCount = pSMB->DataCount;
2057 pSMB->ParameterCount = cpu_to_le16(params);
2058 pSMB->TotalParameterCount = pSMB->ParameterCount;
2059 pSMB->Reserved4 = 0;
2060 pSMB->hdr.smb_buf_length += byte_count;
2061 pSMB->ByteCount = cpu_to_le16(byte_count);
2062 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2063 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2064 if (rc) {
2065 cFYI(1, ("Set POSIX ACL returned %d", rc));
2066 }
2067
2068setACLerrorExit:
2069 cifs_buf_release(pSMB);
2070 if (rc == -EAGAIN)
2071 goto setAclRetry;
2072 return rc;
2073}
2074
2075#endif
2076
2077int
2078CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
2079 const unsigned char *searchName,
2080 FILE_ALL_INFO * pFindData,
2081 const struct nls_table *nls_codepage)
2082{
2083/* level 263 SMB_QUERY_FILE_ALL_INFO */
2084 TRANSACTION2_QPI_REQ *pSMB = NULL;
2085 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2086 int rc = 0;
2087 int bytes_returned;
2088 int name_len;
2089 __u16 params, byte_count;
2090
2091/* cFYI(1, ("In QPathInfo path %s", searchName)); */
2092QPathInfoRetry:
2093 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2094 (void **) &pSMBr);
2095 if (rc)
2096 return rc;
2097
2098 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2099 name_len =
2100 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2101 /* find define for this maxpathcomponent */
2102 , nls_codepage);
2103 name_len++; /* trailing null */
2104 name_len *= 2;
2105 } else { /* BB improve the check for buffer overruns BB */
2106 name_len = strnlen(searchName, PATH_MAX);
2107 name_len++; /* trailing null */
2108 strncpy(pSMB->FileName, searchName, name_len);
2109 }
2110
2111 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2112 pSMB->TotalDataCount = 0;
2113 pSMB->MaxParameterCount = cpu_to_le16(2);
2114 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2115 pSMB->MaxSetupCount = 0;
2116 pSMB->Reserved = 0;
2117 pSMB->Flags = 0;
2118 pSMB->Timeout = 0;
2119 pSMB->Reserved2 = 0;
2120 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2121 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2122 pSMB->DataCount = 0;
2123 pSMB->DataOffset = 0;
2124 pSMB->SetupCount = 1;
2125 pSMB->Reserved3 = 0;
2126 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2127 byte_count = params + 1 /* pad */ ;
2128 pSMB->TotalParameterCount = cpu_to_le16(params);
2129 pSMB->ParameterCount = pSMB->TotalParameterCount;
2130 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
2131 pSMB->Reserved4 = 0;
2132 pSMB->hdr.smb_buf_length += byte_count;
2133 pSMB->ByteCount = cpu_to_le16(byte_count);
2134
2135 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2136 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2137 if (rc) {
2138 cFYI(1, ("Send error in QPathInfo = %d", rc));
2139 } else { /* decode response */
2140 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2141
2142 if (rc || (pSMBr->ByteCount < 40))
2143 rc = -EIO; /* bad smb */
2144 else if (pFindData){
2145 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2146 memcpy((char *) pFindData,
2147 (char *) &pSMBr->hdr.Protocol +
2148 data_offset, sizeof (FILE_ALL_INFO));
2149 } else
2150 rc = -ENOMEM;
2151 }
2152 cifs_buf_release(pSMB);
2153 if (rc == -EAGAIN)
2154 goto QPathInfoRetry;
2155
2156 return rc;
2157}
2158
2159int
2160CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
2161 const unsigned char *searchName,
2162 FILE_UNIX_BASIC_INFO * pFindData,
2163 const struct nls_table *nls_codepage)
2164{
2165/* SMB_QUERY_FILE_UNIX_BASIC */
2166 TRANSACTION2_QPI_REQ *pSMB = NULL;
2167 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2168 int rc = 0;
2169 int bytes_returned = 0;
2170 int name_len;
2171 __u16 params, byte_count;
2172
2173 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
2174UnixQPathInfoRetry:
2175 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2176 (void **) &pSMBr);
2177 if (rc)
2178 return rc;
2179
2180 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2181 name_len =
2182 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2183 /* find define for this maxpathcomponent */
2184 , nls_codepage);
2185 name_len++; /* trailing null */
2186 name_len *= 2;
2187 } else { /* BB improve the check for buffer overruns BB */
2188 name_len = strnlen(searchName, PATH_MAX);
2189 name_len++; /* trailing null */
2190 strncpy(pSMB->FileName, searchName, name_len);
2191 }
2192
2193 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2194 pSMB->TotalDataCount = 0;
2195 pSMB->MaxParameterCount = cpu_to_le16(2);
2196 /* BB find exact max SMB PDU from sess structure BB */
2197 pSMB->MaxDataCount = cpu_to_le16(4000);
2198 pSMB->MaxSetupCount = 0;
2199 pSMB->Reserved = 0;
2200 pSMB->Flags = 0;
2201 pSMB->Timeout = 0;
2202 pSMB->Reserved2 = 0;
2203 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2204 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2205 pSMB->DataCount = 0;
2206 pSMB->DataOffset = 0;
2207 pSMB->SetupCount = 1;
2208 pSMB->Reserved3 = 0;
2209 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2210 byte_count = params + 1 /* pad */ ;
2211 pSMB->TotalParameterCount = cpu_to_le16(params);
2212 pSMB->ParameterCount = pSMB->TotalParameterCount;
2213 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
2214 pSMB->Reserved4 = 0;
2215 pSMB->hdr.smb_buf_length += byte_count;
2216 pSMB->ByteCount = cpu_to_le16(byte_count);
2217
2218 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2219 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2220 if (rc) {
2221 cFYI(1, ("Send error in QPathInfo = %d", rc));
2222 } else { /* decode response */
2223 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2224
2225 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
2226 rc = -EIO; /* bad smb */
2227 } else {
2228 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2229 memcpy((char *) pFindData,
2230 (char *) &pSMBr->hdr.Protocol +
2231 data_offset,
2232 sizeof (FILE_UNIX_BASIC_INFO));
2233 }
2234 }
2235 cifs_buf_release(pSMB);
2236 if (rc == -EAGAIN)
2237 goto UnixQPathInfoRetry;
2238
2239 return rc;
2240}
2241
2242#if 0 /* function unused at present */
2243int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
2244 const char *searchName, FILE_ALL_INFO * findData,
2245 const struct nls_table *nls_codepage)
2246{
2247/* level 257 SMB_ */
2248 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2249 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2250 int rc = 0;
2251 int bytes_returned;
2252 int name_len;
2253 __u16 params, byte_count;
2254
2255 cFYI(1, ("In FindUnique"));
2256findUniqueRetry:
2257 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2258 (void **) &pSMBr);
2259 if (rc)
2260 return rc;
2261
2262 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2263 name_len =
2264 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2265 /* find define for this maxpathcomponent */
2266 , nls_codepage);
2267 name_len++; /* trailing null */
2268 name_len *= 2;
2269 } else { /* BB improve the check for buffer overruns BB */
2270 name_len = strnlen(searchName, PATH_MAX);
2271 name_len++; /* trailing null */
2272 strncpy(pSMB->FileName, searchName, name_len);
2273 }
2274
2275 params = 12 + name_len /* includes null */ ;
2276 pSMB->TotalDataCount = 0; /* no EAs */
2277 pSMB->MaxParameterCount = cpu_to_le16(2);
2278 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2279 pSMB->MaxSetupCount = 0;
2280 pSMB->Reserved = 0;
2281 pSMB->Flags = 0;
2282 pSMB->Timeout = 0;
2283 pSMB->Reserved2 = 0;
2284 pSMB->ParameterOffset = cpu_to_le16(
2285 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
2286 pSMB->DataCount = 0;
2287 pSMB->DataOffset = 0;
2288 pSMB->SetupCount = 1; /* one byte, no need to le convert */
2289 pSMB->Reserved3 = 0;
2290 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2291 byte_count = params + 1 /* pad */ ;
2292 pSMB->TotalParameterCount = cpu_to_le16(params);
2293 pSMB->ParameterCount = pSMB->TotalParameterCount;
2294 pSMB->SearchAttributes =
2295 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2296 ATTR_DIRECTORY);
2297 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
2298 pSMB->SearchFlags = cpu_to_le16(1);
2299 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2300 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
2301 pSMB->hdr.smb_buf_length += byte_count;
2302 pSMB->ByteCount = cpu_to_le16(byte_count);
2303
2304 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2305 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2306
2307 if (rc) {
2308 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
2309 } else { /* decode response */
2310
2311 /* BB fill in */
2312 }
2313
2314 cifs_buf_release(pSMB);
2315 if (rc == -EAGAIN)
2316 goto findUniqueRetry;
2317
2318 return rc;
2319}
2320#endif /* end unused (temporarily) function */
2321
2322/* xid, tcon, searchName and codepage are input parms, rest are returned */
2323int
2324CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
2325 const char *searchName,
2326 const struct nls_table *nls_codepage,
2327 __u16 * pnetfid,
2328 struct cifs_search_info * psrch_inf)
2329{
2330/* level 257 SMB_ */
2331 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2332 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2333 T2_FFIRST_RSP_PARMS * parms;
2334 int rc = 0;
2335 int bytes_returned = 0;
2336 int name_len;
2337 __u16 params, byte_count;
2338
2339 cFYI(1, ("In FindFirst"));
2340
2341findFirstRetry:
2342 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2343 (void **) &pSMBr);
2344 if (rc)
2345 return rc;
2346
2347 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2348 name_len =
2349 cifs_strtoUCS((wchar_t *) pSMB->FileName,searchName,
2350 PATH_MAX, nls_codepage);
2351 name_len++; /* trailing null */
2352 name_len *= 2;
2353 pSMB->FileName[name_len] = 0; /* null terminate just in case */
2354 pSMB->FileName[name_len+1] = 0;
2355 } else { /* BB add check for overrun of SMB buf BB */
2356 name_len = strnlen(searchName, PATH_MAX);
2357 name_len++; /* trailing null */
2358/* BB fix here and in unicode clause above ie
2359 if(name_len > buffersize-header)
2360 free buffer exit; BB */
2361 strncpy(pSMB->FileName, searchName, name_len);
2362 pSMB->FileName[name_len] = 0; /* just in case */
2363 }
2364
2365 params = 12 + name_len /* includes null */ ;
2366 pSMB->TotalDataCount = 0; /* no EAs */
2367 pSMB->MaxParameterCount = cpu_to_le16(10);
2368 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
2369 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2370 pSMB->MaxSetupCount = 0;
2371 pSMB->Reserved = 0;
2372 pSMB->Flags = 0;
2373 pSMB->Timeout = 0;
2374 pSMB->Reserved2 = 0;
2375 byte_count = params + 1 /* pad */ ;
2376 pSMB->TotalParameterCount = cpu_to_le16(params);
2377 pSMB->ParameterCount = pSMB->TotalParameterCount;
2378 pSMB->ParameterOffset = cpu_to_le16(
2379 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
2380 pSMB->DataCount = 0;
2381 pSMB->DataOffset = 0;
2382 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
2383 pSMB->Reserved3 = 0;
2384 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2385 pSMB->SearchAttributes =
2386 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2387 ATTR_DIRECTORY);
2388 pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
2389 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
2390 CIFS_SEARCH_RETURN_RESUME);
2391 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2392
2393 /* BB what should we set StorageType to? Does it matter? BB */
2394 pSMB->SearchStorageType = 0;
2395 pSMB->hdr.smb_buf_length += byte_count;
2396 pSMB->ByteCount = cpu_to_le16(byte_count);
2397
2398 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2399 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2400
2401 if (rc) {/* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
2402 /* BB Add code to handle unsupported level rc */
2403 cFYI(1, ("Error in FindFirst = %d", rc));
2404
2405 if (pSMB)
2406 cifs_buf_release(pSMB);
2407
2408 /* BB eventually could optimize out free and realloc of buf */
2409 /* for this case */
2410 if (rc == -EAGAIN)
2411 goto findFirstRetry;
2412 } else { /* decode response */
2413 /* BB remember to free buffer if error BB */
2414 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2415 if(rc == 0) {
2416 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2417 psrch_inf->unicode = TRUE;
2418 else
2419 psrch_inf->unicode = FALSE;
2420
2421 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
2422 psrch_inf->srch_entries_start =
2423 (char *) &pSMBr->hdr.Protocol +
2424 le16_to_cpu(pSMBr->t2.DataOffset);
2425
2426 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
2427 le16_to_cpu(pSMBr->t2.ParameterOffset));
2428
2429 if(parms->EndofSearch)
2430 psrch_inf->endOfSearch = TRUE;
2431 else
2432 psrch_inf->endOfSearch = FALSE;
2433
2434 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2435 psrch_inf->index_of_last_entry =
2436 psrch_inf->entries_in_buffer;
2437/*cFYI(1,("entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
2438 *pnetfid = parms->SearchHandle;
2439 } else {
2440 cifs_buf_release(pSMB);
2441 }
2442 }
2443
2444 return rc;
2445}
2446
2447int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
2448 __u16 searchHandle, struct cifs_search_info * psrch_inf)
2449{
2450 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
2451 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
2452 T2_FNEXT_RSP_PARMS * parms;
2453 char *response_data;
2454 int rc = 0;
2455 int bytes_returned, name_len;
2456 __u16 params, byte_count;
2457
2458 cFYI(1, ("In FindNext"));
2459
2460 if(psrch_inf->endOfSearch == TRUE)
2461 return -ENOENT;
2462
2463 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2464 (void **) &pSMBr);
2465 if (rc)
2466 return rc;
2467
2468 params = 14; /* includes 2 bytes of null string, converted to LE below */
2469 byte_count = 0;
2470 pSMB->TotalDataCount = 0; /* no EAs */
2471 pSMB->MaxParameterCount = cpu_to_le16(8);
2472 pSMB->MaxDataCount =
2473 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2474 pSMB->MaxSetupCount = 0;
2475 pSMB->Reserved = 0;
2476 pSMB->Flags = 0;
2477 pSMB->Timeout = 0;
2478 pSMB->Reserved2 = 0;
2479 pSMB->ParameterOffset = cpu_to_le16(
2480 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
2481 pSMB->DataCount = 0;
2482 pSMB->DataOffset = 0;
2483 pSMB->SetupCount = 1;
2484 pSMB->Reserved3 = 0;
2485 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
2486 pSMB->SearchHandle = searchHandle; /* always kept as le */
2487 pSMB->SearchCount =
2488 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
2489 /* test for Unix extensions */
2490/* if (tcon->ses->capabilities & CAP_UNIX) {
2491 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
2492 psrch_inf->info_level = SMB_FIND_FILE_UNIX;
2493 } else {
2494 pSMB->InformationLevel =
2495 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2496 psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
2497 } */
2498 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2499 pSMB->ResumeKey = psrch_inf->resume_key;
2500 pSMB->SearchFlags =
2501 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
2502
2503 name_len = psrch_inf->resume_name_len;
2504 params += name_len;
2505 if(name_len < PATH_MAX) {
2506 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
2507 byte_count += name_len;
2508 } else {
2509 rc = -EINVAL;
2510 goto FNext2_err_exit;
2511 }
2512 byte_count = params + 1 /* pad */ ;
2513 pSMB->TotalParameterCount = cpu_to_le16(params);
2514 pSMB->ParameterCount = pSMB->TotalParameterCount;
2515 pSMB->hdr.smb_buf_length += byte_count;
2516 pSMB->ByteCount = cpu_to_le16(byte_count);
2517
2518 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2519 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2520
2521 if (rc) {
2522 if (rc == -EBADF) {
2523 psrch_inf->endOfSearch = TRUE;
2524 rc = 0; /* search probably was closed at end of search above */
2525 } else
2526 cFYI(1, ("FindNext returned = %d", rc));
2527 } else { /* decode response */
2528 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2529
2530 if(rc == 0) {
2531 /* BB fixme add lock for file (srch_info) struct here */
2532 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2533 psrch_inf->unicode = TRUE;
2534 else
2535 psrch_inf->unicode = FALSE;
2536 response_data = (char *) &pSMBr->hdr.Protocol +
2537 le16_to_cpu(pSMBr->t2.ParameterOffset);
2538 parms = (T2_FNEXT_RSP_PARMS *)response_data;
2539 response_data = (char *)&pSMBr->hdr.Protocol +
2540 le16_to_cpu(pSMBr->t2.DataOffset);
2541 cifs_buf_release(psrch_inf->ntwrk_buf_start);
2542 psrch_inf->srch_entries_start = response_data;
2543 psrch_inf->ntwrk_buf_start = (char *)pSMB;
2544 if(parms->EndofSearch)
2545 psrch_inf->endOfSearch = TRUE;
2546 else
2547 psrch_inf->endOfSearch = FALSE;
2548
2549 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2550 psrch_inf->index_of_last_entry +=
2551 psrch_inf->entries_in_buffer;
2552/* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
2553
2554 /* BB fixme add unlock here */
2555 }
2556
2557 }
2558
2559 /* BB On error, should we leave previous search buf (and count and
2560 last entry fields) intact or free the previous one? */
2561
2562 /* Note: On -EAGAIN error only caller can retry on handle based calls
2563 since file handle passed in no longer valid */
2564FNext2_err_exit:
2565 if (rc != 0)
2566 cifs_buf_release(pSMB);
2567
2568 return rc;
2569}
2570
2571int
2572CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
2573{
2574 int rc = 0;
2575 FINDCLOSE_REQ *pSMB = NULL;
2576 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
2577 int bytes_returned;
2578
2579 cFYI(1, ("In CIFSSMBFindClose"));
2580 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
2581
2582 /* no sense returning error if session restarted
2583 as file handle has been closed */
2584 if(rc == -EAGAIN)
2585 return 0;
2586 if (rc)
2587 return rc;
2588
2589 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
2590 pSMB->FileID = searchHandle;
2591 pSMB->ByteCount = 0;
2592 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2593 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2594 if (rc) {
2595 cERROR(1, ("Send error in FindClose = %d", rc));
2596 }
2597 cifs_small_buf_release(pSMB);
2598
2599 /* Since session is dead, search handle closed on server already */
2600 if (rc == -EAGAIN)
2601 rc = 0;
2602
2603 return rc;
2604}
2605
2606#ifdef CONFIG_CIFS_EXPERIMENTAL
2607int
2608CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
2609 const unsigned char *searchName,
2610 __u64 * inode_number,
2611 const struct nls_table *nls_codepage)
2612{
2613 int rc = 0;
2614 TRANSACTION2_QPI_REQ *pSMB = NULL;
2615 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2616 int name_len, bytes_returned;
2617 __u16 params, byte_count;
2618
2619 cFYI(1,("In GetSrvInodeNum for %s",searchName));
2620 if(tcon == NULL)
2621 return -ENODEV;
2622
2623GetInodeNumberRetry:
2624 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2625 (void **) &pSMBr);
2626 if (rc)
2627 return rc;
2628
2629
2630 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2631 name_len =
2632 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName,
2633 PATH_MAX,nls_codepage);
2634 name_len++; /* trailing null */
2635 name_len *= 2;
2636 } else { /* BB improve the check for buffer overruns BB */
2637 name_len = strnlen(searchName, PATH_MAX);
2638 name_len++; /* trailing null */
2639 strncpy(pSMB->FileName, searchName, name_len);
2640 }
2641
2642 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2643 pSMB->TotalDataCount = 0;
2644 pSMB->MaxParameterCount = cpu_to_le16(2);
2645 /* BB find exact max data count below from sess structure BB */
2646 pSMB->MaxDataCount = cpu_to_le16(4000);
2647 pSMB->MaxSetupCount = 0;
2648 pSMB->Reserved = 0;
2649 pSMB->Flags = 0;
2650 pSMB->Timeout = 0;
2651 pSMB->Reserved2 = 0;
2652 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2653 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2654 pSMB->DataCount = 0;
2655 pSMB->DataOffset = 0;
2656 pSMB->SetupCount = 1;
2657 pSMB->Reserved3 = 0;
2658 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2659 byte_count = params + 1 /* pad */ ;
2660 pSMB->TotalParameterCount = cpu_to_le16(params);
2661 pSMB->ParameterCount = pSMB->TotalParameterCount;
2662 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
2663 pSMB->Reserved4 = 0;
2664 pSMB->hdr.smb_buf_length += byte_count;
2665 pSMB->ByteCount = cpu_to_le16(byte_count);
2666
2667 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2668 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2669 if (rc) {
2670 cFYI(1, ("error %d in QueryInternalInfo", rc));
2671 } else {
2672 /* decode response */
2673 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2674 if (rc || (pSMBr->ByteCount < 2))
2675 /* BB also check enough total bytes returned */
2676 /* If rc should we check for EOPNOSUPP and
2677 disable the srvino flag? or in caller? */
2678 rc = -EIO; /* bad smb */
2679 else {
2680 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2681 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2682 struct file_internal_info * pfinfo;
2683 /* BB Do we need a cast or hash here ? */
2684 if(count < 8) {
2685 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
2686 rc = -EIO;
2687 goto GetInodeNumOut;
2688 }
2689 pfinfo = (struct file_internal_info *)
2690 (data_offset + (char *) &pSMBr->hdr.Protocol);
2691 *inode_number = pfinfo->UniqueId;
2692 }
2693 }
2694GetInodeNumOut:
2695 cifs_buf_release(pSMB);
2696 if (rc == -EAGAIN)
2697 goto GetInodeNumberRetry;
2698 return rc;
2699}
2700#endif /* CIFS_EXPERIMENTAL */
2701
2702int
2703CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
2704 const unsigned char *searchName,
2705 unsigned char **targetUNCs,
2706 unsigned int *number_of_UNC_in_array,
2707 const struct nls_table *nls_codepage)
2708{
2709/* TRANS2_GET_DFS_REFERRAL */
2710 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
2711 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
2712 struct dfs_referral_level_3 * referrals = NULL;
2713 int rc = 0;
2714 int bytes_returned;
2715 int name_len;
2716 unsigned int i;
2717 char * temp;
2718 __u16 params, byte_count;
2719 *number_of_UNC_in_array = 0;
2720 *targetUNCs = NULL;
2721
2722 cFYI(1, ("In GetDFSRefer the path %s", searchName));
2723 if (ses == NULL)
2724 return -ENODEV;
2725getDFSRetry:
2726 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
2727 (void **) &pSMBr);
2728 if (rc)
2729 return rc;
2730
2731 pSMB->hdr.Tid = ses->ipc_tid;
2732 pSMB->hdr.Uid = ses->Suid;
2733 if (ses->capabilities & CAP_STATUS32) {
2734 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
2735 }
2736 if (ses->capabilities & CAP_DFS) {
2737 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
2738 }
2739
2740 if (ses->capabilities & CAP_UNICODE) {
2741 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
2742 name_len =
2743 cifs_strtoUCS((wchar_t *) pSMB->RequestFileName,
2744 searchName, PATH_MAX
2745 /* find define for this maxpathcomponent */
2746 , nls_codepage);
2747 name_len++; /* trailing null */
2748 name_len *= 2;
2749 } else { /* BB improve the check for buffer overruns BB */
2750 name_len = strnlen(searchName, PATH_MAX);
2751 name_len++; /* trailing null */
2752 strncpy(pSMB->RequestFileName, searchName, name_len);
2753 }
2754
2755 params = 2 /* level */ + name_len /*includes null */ ;
2756 pSMB->TotalDataCount = 0;
2757 pSMB->DataCount = 0;
2758 pSMB->DataOffset = 0;
2759 pSMB->MaxParameterCount = 0;
2760 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2761 pSMB->MaxSetupCount = 0;
2762 pSMB->Reserved = 0;
2763 pSMB->Flags = 0;
2764 pSMB->Timeout = 0;
2765 pSMB->Reserved2 = 0;
2766 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2767 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
2768 pSMB->SetupCount = 1;
2769 pSMB->Reserved3 = 0;
2770 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
2771 byte_count = params + 3 /* pad */ ;
2772 pSMB->ParameterCount = cpu_to_le16(params);
2773 pSMB->TotalParameterCount = pSMB->ParameterCount;
2774 pSMB->MaxReferralLevel = cpu_to_le16(3);
2775 pSMB->hdr.smb_buf_length += byte_count;
2776 pSMB->ByteCount = cpu_to_le16(byte_count);
2777
2778 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
2779 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2780 if (rc) {
2781 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
2782 } else { /* decode response */
2783/* BB Add logic to parse referrals here */
2784 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2785
2786 if (rc || (pSMBr->ByteCount < 17)) /* BB also check enough total bytes returned */
2787 rc = -EIO; /* bad smb */
2788 else {
2789 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2790 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2791
2792 cFYI(1,
2793 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
2794 pSMBr->ByteCount, data_offset));
2795 referrals =
2796 (struct dfs_referral_level_3 *)
2797 (8 /* sizeof start of data block */ +
2798 data_offset +
2799 (char *) &pSMBr->hdr.Protocol);
2800 cFYI(1,("num_referrals: %d dfs flags: 0x%x ... \nfor referral one refer size: 0x%x srv type: 0x%x refer flags: 0x%x ttl: 0x%x",
2801 le16_to_cpu(pSMBr->NumberOfReferrals),le16_to_cpu(pSMBr->DFSFlags), le16_to_cpu(referrals->ReferralSize),le16_to_cpu(referrals->ServerType),le16_to_cpu(referrals->ReferralFlags),le16_to_cpu(referrals->TimeToLive)));
2802 /* BB This field is actually two bytes in from start of
2803 data block so we could do safety check that DataBlock
2804 begins at address of pSMBr->NumberOfReferrals */
2805 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
2806
2807 /* BB Fix below so can return more than one referral */
2808 if(*number_of_UNC_in_array > 1)
2809 *number_of_UNC_in_array = 1;
2810
2811 /* get the length of the strings describing refs */
2812 name_len = 0;
2813 for(i=0;i<*number_of_UNC_in_array;i++) {
2814 /* make sure that DfsPathOffset not past end */
2815 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
2816 if (offset > data_count) {
2817 /* if invalid referral, stop here and do
2818 not try to copy any more */
2819 *number_of_UNC_in_array = i;
2820 break;
2821 }
2822 temp = ((char *)referrals) + offset;
2823
2824 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2825 name_len += UniStrnlen((wchar_t *)temp,data_count);
2826 } else {
2827 name_len += strnlen(temp,data_count);
2828 }
2829 referrals++;
2830 /* BB add check that referral pointer does not fall off end PDU */
2831
2832 }
2833 /* BB add check for name_len bigger than bcc */
2834 *targetUNCs =
2835 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
2836 if(*targetUNCs == NULL) {
2837 rc = -ENOMEM;
2838 goto GetDFSRefExit;
2839 }
2840 /* copy the ref strings */
2841 referrals =
2842 (struct dfs_referral_level_3 *)
2843 (8 /* sizeof data hdr */ +
2844 data_offset +
2845 (char *) &pSMBr->hdr.Protocol);
2846
2847 for(i=0;i<*number_of_UNC_in_array;i++) {
2848 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
2849 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2850 cifs_strfromUCS_le(*targetUNCs,
2851 (wchar_t *) temp, name_len, nls_codepage);
2852 } else {
2853 strncpy(*targetUNCs,temp,name_len);
2854 }
2855 /* BB update target_uncs pointers */
2856 referrals++;
2857 }
2858 temp = *targetUNCs;
2859 temp[name_len] = 0;
2860 }
2861
2862 }
2863GetDFSRefExit:
2864 if (pSMB)
2865 cifs_buf_release(pSMB);
2866
2867 if (rc == -EAGAIN)
2868 goto getDFSRetry;
2869
2870 return rc;
2871}
2872
2873int
2874CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
2875 struct kstatfs *FSData, const struct nls_table *nls_codepage)
2876{
2877/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
2878 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2879 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2880 FILE_SYSTEM_INFO *response_data;
2881 int rc = 0;
2882 int bytes_returned = 0;
2883 __u16 params, byte_count;
2884
2885 cFYI(1, ("In QFSInfo"));
2886QFSInfoRetry:
2887 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2888 (void **) &pSMBr);
2889 if (rc)
2890 return rc;
2891
2892 params = 2; /* level */
2893 pSMB->TotalDataCount = 0;
2894 pSMB->MaxParameterCount = cpu_to_le16(2);
2895 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2896 pSMB->MaxSetupCount = 0;
2897 pSMB->Reserved = 0;
2898 pSMB->Flags = 0;
2899 pSMB->Timeout = 0;
2900 pSMB->Reserved2 = 0;
2901 byte_count = params + 1 /* pad */ ;
2902 pSMB->TotalParameterCount = cpu_to_le16(params);
2903 pSMB->ParameterCount = pSMB->TotalParameterCount;
2904 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2905 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2906 pSMB->DataCount = 0;
2907 pSMB->DataOffset = 0;
2908 pSMB->SetupCount = 1;
2909 pSMB->Reserved3 = 0;
2910 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2911 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
2912 pSMB->hdr.smb_buf_length += byte_count;
2913 pSMB->ByteCount = cpu_to_le16(byte_count);
2914
2915 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2916 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2917 if (rc) {
2918 cERROR(1, ("Send error in QFSInfo = %d", rc));
2919 } else { /* decode response */
2920 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2921
2922 if (rc || (pSMBr->ByteCount < 24)) /* BB alsO CHEck enough total bytes returned */
2923 rc = -EIO; /* bad smb */
2924 else {
2925 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2926 cFYI(1,
2927 ("Decoding qfsinfo response. BCC: %d Offset %d",
2928 pSMBr->ByteCount, data_offset));
2929
2930 response_data =
2931 (FILE_SYSTEM_INFO
2932 *) (((char *) &pSMBr->hdr.Protocol) +
2933 data_offset);
2934 FSData->f_bsize =
2935 le32_to_cpu(response_data->BytesPerSector) *
2936 le32_to_cpu(response_data->
2937 SectorsPerAllocationUnit);
2938 FSData->f_blocks =
2939 le64_to_cpu(response_data->TotalAllocationUnits);
2940 FSData->f_bfree = FSData->f_bavail =
2941 le64_to_cpu(response_data->FreeAllocationUnits);
2942 cFYI(1,
2943 ("Blocks: %lld Free: %lld Block size %ld",
2944 (unsigned long long)FSData->f_blocks,
2945 (unsigned long long)FSData->f_bfree,
2946 FSData->f_bsize));
2947 }
2948 }
2949 cifs_buf_release(pSMB);
2950
2951 if (rc == -EAGAIN)
2952 goto QFSInfoRetry;
2953
2954 return rc;
2955}
2956
2957int
2958CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon,
2959 const struct nls_table *nls_codepage)
2960{
2961/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
2962 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2963 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2964 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
2965 int rc = 0;
2966 int bytes_returned = 0;
2967 __u16 params, byte_count;
2968
2969 cFYI(1, ("In QFSAttributeInfo"));
2970QFSAttributeRetry:
2971 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2972 (void **) &pSMBr);
2973 if (rc)
2974 return rc;
2975
2976 params = 2; /* level */
2977 pSMB->TotalDataCount = 0;
2978 pSMB->MaxParameterCount = cpu_to_le16(2);
2979 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2980 pSMB->MaxSetupCount = 0;
2981 pSMB->Reserved = 0;
2982 pSMB->Flags = 0;
2983 pSMB->Timeout = 0;
2984 pSMB->Reserved2 = 0;
2985 byte_count = params + 1 /* pad */ ;
2986 pSMB->TotalParameterCount = cpu_to_le16(params);
2987 pSMB->ParameterCount = pSMB->TotalParameterCount;
2988 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2989 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2990 pSMB->DataCount = 0;
2991 pSMB->DataOffset = 0;
2992 pSMB->SetupCount = 1;
2993 pSMB->Reserved3 = 0;
2994 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2995 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
2996 pSMB->hdr.smb_buf_length += byte_count;
2997 pSMB->ByteCount = cpu_to_le16(byte_count);
2998
2999 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3000 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3001 if (rc) {
3002 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
3003 } else { /* decode response */
3004 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3005
3006 if (rc || (pSMBr->ByteCount < 13)) { /* BB also check enough bytes returned */
3007 rc = -EIO; /* bad smb */
3008 } else {
3009 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3010 response_data =
3011 (FILE_SYSTEM_ATTRIBUTE_INFO
3012 *) (((char *) &pSMBr->hdr.Protocol) +
3013 data_offset);
3014 memcpy(&tcon->fsAttrInfo, response_data,
3015 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
3016 }
3017 }
3018 cifs_buf_release(pSMB);
3019
3020 if (rc == -EAGAIN)
3021 goto QFSAttributeRetry;
3022
3023 return rc;
3024}
3025
3026int
3027CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon,
3028 const struct nls_table *nls_codepage)
3029{
3030/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
3031 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3032 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3033 FILE_SYSTEM_DEVICE_INFO *response_data;
3034 int rc = 0;
3035 int bytes_returned = 0;
3036 __u16 params, byte_count;
3037
3038 cFYI(1, ("In QFSDeviceInfo"));
3039QFSDeviceRetry:
3040 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3041 (void **) &pSMBr);
3042 if (rc)
3043 return rc;
3044
3045 params = 2; /* level */
3046 pSMB->TotalDataCount = 0;
3047 pSMB->MaxParameterCount = cpu_to_le16(2);
3048 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3049 pSMB->MaxSetupCount = 0;
3050 pSMB->Reserved = 0;
3051 pSMB->Flags = 0;
3052 pSMB->Timeout = 0;
3053 pSMB->Reserved2 = 0;
3054 byte_count = params + 1 /* pad */ ;
3055 pSMB->TotalParameterCount = cpu_to_le16(params);
3056 pSMB->ParameterCount = pSMB->TotalParameterCount;
3057 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3058 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3059
3060 pSMB->DataCount = 0;
3061 pSMB->DataOffset = 0;
3062 pSMB->SetupCount = 1;
3063 pSMB->Reserved3 = 0;
3064 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3065 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
3066 pSMB->hdr.smb_buf_length += byte_count;
3067 pSMB->ByteCount = cpu_to_le16(byte_count);
3068
3069 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3070 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3071 if (rc) {
3072 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
3073 } else { /* decode response */
3074 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3075
3076 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
3077 rc = -EIO; /* bad smb */
3078 else {
3079 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3080 response_data =
3081 (FILE_SYSTEM_DEVICE_INFO
3082 *) (((char *) &pSMBr->hdr.Protocol) +
3083 data_offset);
3084 memcpy(&tcon->fsDevInfo, response_data,
3085 sizeof (FILE_SYSTEM_DEVICE_INFO));
3086 }
3087 }
3088 cifs_buf_release(pSMB);
3089
3090 if (rc == -EAGAIN)
3091 goto QFSDeviceRetry;
3092
3093 return rc;
3094}
3095
3096int
3097CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon,
3098 const struct nls_table *nls_codepage)
3099{
3100/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
3101 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3102 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3103 FILE_SYSTEM_UNIX_INFO *response_data;
3104 int rc = 0;
3105 int bytes_returned = 0;
3106 __u16 params, byte_count;
3107
3108 cFYI(1, ("In QFSUnixInfo"));
3109QFSUnixRetry:
3110 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3111 (void **) &pSMBr);
3112 if (rc)
3113 return rc;
3114
3115 params = 2; /* level */
3116 pSMB->TotalDataCount = 0;
3117 pSMB->DataCount = 0;
3118 pSMB->DataOffset = 0;
3119 pSMB->MaxParameterCount = cpu_to_le16(2);
3120 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3121 pSMB->MaxSetupCount = 0;
3122 pSMB->Reserved = 0;
3123 pSMB->Flags = 0;
3124 pSMB->Timeout = 0;
3125 pSMB->Reserved2 = 0;
3126 byte_count = params + 1 /* pad */ ;
3127 pSMB->ParameterCount = cpu_to_le16(params);
3128 pSMB->TotalParameterCount = pSMB->ParameterCount;
3129 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3130 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3131 pSMB->SetupCount = 1;
3132 pSMB->Reserved3 = 0;
3133 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3134 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
3135 pSMB->hdr.smb_buf_length += byte_count;
3136 pSMB->ByteCount = cpu_to_le16(byte_count);
3137
3138 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3139 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3140 if (rc) {
3141 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
3142 } else { /* decode response */
3143 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3144
3145 if (rc || (pSMBr->ByteCount < 13)) {
3146 rc = -EIO; /* bad smb */
3147 } else {
3148 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3149 response_data =
3150 (FILE_SYSTEM_UNIX_INFO
3151 *) (((char *) &pSMBr->hdr.Protocol) +
3152 data_offset);
3153 memcpy(&tcon->fsUnixInfo, response_data,
3154 sizeof (FILE_SYSTEM_UNIX_INFO));
3155 }
3156 }
3157 cifs_buf_release(pSMB);
3158
3159 if (rc == -EAGAIN)
3160 goto QFSUnixRetry;
3161
3162
3163 return rc;
3164}
3165
3166
3167int
3168CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
3169 struct kstatfs *FSData, const struct nls_table *nls_codepage)
3170{
3171/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
3172 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3173 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3174 FILE_SYSTEM_POSIX_INFO *response_data;
3175 int rc = 0;
3176 int bytes_returned = 0;
3177 __u16 params, byte_count;
3178
3179 cFYI(1, ("In QFSPosixInfo"));
3180QFSPosixRetry:
3181 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3182 (void **) &pSMBr);
3183 if (rc)
3184 return rc;
3185
3186 params = 2; /* level */
3187 pSMB->TotalDataCount = 0;
3188 pSMB->DataCount = 0;
3189 pSMB->DataOffset = 0;
3190 pSMB->MaxParameterCount = cpu_to_le16(2);
3191 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3192 pSMB->MaxSetupCount = 0;
3193 pSMB->Reserved = 0;
3194 pSMB->Flags = 0;
3195 pSMB->Timeout = 0;
3196 pSMB->Reserved2 = 0;
3197 byte_count = params + 1 /* pad */ ;
3198 pSMB->ParameterCount = cpu_to_le16(params);
3199 pSMB->TotalParameterCount = pSMB->ParameterCount;
3200 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3201 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3202 pSMB->SetupCount = 1;
3203 pSMB->Reserved3 = 0;
3204 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3205 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
3206 pSMB->hdr.smb_buf_length += byte_count;
3207 pSMB->ByteCount = cpu_to_le16(byte_count);
3208
3209 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3210 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3211 if (rc) {
3212 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
3213 } else { /* decode response */
3214 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3215
3216 if (rc || (pSMBr->ByteCount < 13)) {
3217 rc = -EIO; /* bad smb */
3218 } else {
3219 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3220 response_data =
3221 (FILE_SYSTEM_POSIX_INFO
3222 *) (((char *) &pSMBr->hdr.Protocol) +
3223 data_offset);
3224 FSData->f_bsize =
3225 le32_to_cpu(response_data->BlockSize);
3226 FSData->f_blocks =
3227 le64_to_cpu(response_data->TotalBlocks);
3228 FSData->f_bfree =
3229 le64_to_cpu(response_data->BlocksAvail);
3230 if(response_data->UserBlocksAvail == -1) {
3231 FSData->f_bavail = FSData->f_bfree;
3232 } else {
3233 FSData->f_bavail =
3234 le64_to_cpu(response_data->UserBlocksAvail);
3235 }
3236 if(response_data->TotalFileNodes != -1)
3237 FSData->f_files =
3238 le64_to_cpu(response_data->TotalFileNodes);
3239 if(response_data->FreeFileNodes != -1)
3240 FSData->f_ffree =
3241 le64_to_cpu(response_data->FreeFileNodes);
3242 }
3243 }
3244 cifs_buf_release(pSMB);
3245
3246 if (rc == -EAGAIN)
3247 goto QFSPosixRetry;
3248
3249 return rc;
3250}
3251
3252
3253/* We can not use write of zero bytes trick to
3254 set file size due to need for large file support. Also note that
3255 this SetPathInfo is preferred to SetFileInfo based method in next
3256 routine which is only needed to work around a sharing violation bug
3257 in Samba which this routine can run into */
3258
3259int
3260CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3261 __u64 size, int SetAllocation, const struct nls_table *nls_codepage)
3262{
3263 struct smb_com_transaction2_spi_req *pSMB = NULL;
3264 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3265 struct file_end_of_file_info *parm_data;
3266 int name_len;
3267 int rc = 0;
3268 int bytes_returned = 0;
3269 __u16 params, byte_count, data_count, param_offset, offset;
3270
3271 cFYI(1, ("In SetEOF"));
3272SetEOFRetry:
3273 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3274 (void **) &pSMBr);
3275 if (rc)
3276 return rc;
3277
3278 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3279 name_len =
3280 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3281 /* find define for this maxpathcomponent */
3282 , nls_codepage);
3283 name_len++; /* trailing null */
3284 name_len *= 2;
3285 } else { /* BB improve the check for buffer overruns BB */
3286 name_len = strnlen(fileName, PATH_MAX);
3287 name_len++; /* trailing null */
3288 strncpy(pSMB->FileName, fileName, name_len);
3289 }
3290 params = 6 + name_len;
3291 data_count = sizeof (struct file_end_of_file_info);
3292 pSMB->MaxParameterCount = cpu_to_le16(2);
3293 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
3294 pSMB->MaxSetupCount = 0;
3295 pSMB->Reserved = 0;
3296 pSMB->Flags = 0;
3297 pSMB->Timeout = 0;
3298 pSMB->Reserved2 = 0;
3299 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3300 InformationLevel) - 4;
3301 offset = param_offset + params;
3302 if(SetAllocation) {
3303 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3304 pSMB->InformationLevel =
3305 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3306 else
3307 pSMB->InformationLevel =
3308 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3309 } else /* Set File Size */ {
3310 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3311 pSMB->InformationLevel =
3312 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3313 else
3314 pSMB->InformationLevel =
3315 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3316 }
3317
3318 parm_data =
3319 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3320 offset);
3321 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3322 pSMB->DataOffset = cpu_to_le16(offset);
3323 pSMB->SetupCount = 1;
3324 pSMB->Reserved3 = 0;
3325 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3326 byte_count = 3 /* pad */ + params + data_count;
3327 pSMB->DataCount = cpu_to_le16(data_count);
3328 pSMB->TotalDataCount = pSMB->DataCount;
3329 pSMB->ParameterCount = cpu_to_le16(params);
3330 pSMB->TotalParameterCount = pSMB->ParameterCount;
3331 pSMB->Reserved4 = 0;
3332 pSMB->hdr.smb_buf_length += byte_count;
3333 parm_data->FileSize = cpu_to_le64(size);
3334 pSMB->ByteCount = cpu_to_le16(byte_count);
3335 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3336 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3337 if (rc) {
3338 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
3339 }
3340
3341 cifs_buf_release(pSMB);
3342
3343 if (rc == -EAGAIN)
3344 goto SetEOFRetry;
3345
3346 return rc;
3347}
3348
3349int
3350CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
3351 __u16 fid, __u32 pid_of_opener, int SetAllocation)
3352{
3353 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3354 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3355 char *data_offset;
3356 struct file_end_of_file_info *parm_data;
3357 int rc = 0;
3358 int bytes_returned = 0;
3359 __u16 params, param_offset, offset, byte_count, count;
3360
3361 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
3362 (long long)size));
3363 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3364 (void **) &pSMBr);
3365 if (rc)
3366 return rc;
3367
3368 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3369 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
3370
3371 params = 6;
3372 pSMB->MaxSetupCount = 0;
3373 pSMB->Reserved = 0;
3374 pSMB->Flags = 0;
3375 pSMB->Timeout = 0;
3376 pSMB->Reserved2 = 0;
3377 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3378 offset = param_offset + params;
3379
3380 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3381
3382 count = sizeof(struct file_end_of_file_info);
3383 pSMB->MaxParameterCount = cpu_to_le16(2);
3384 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3385 pSMB->SetupCount = 1;
3386 pSMB->Reserved3 = 0;
3387 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3388 byte_count = 3 /* pad */ + params + count;
3389 pSMB->DataCount = cpu_to_le16(count);
3390 pSMB->ParameterCount = cpu_to_le16(params);
3391 pSMB->TotalDataCount = pSMB->DataCount;
3392 pSMB->TotalParameterCount = pSMB->ParameterCount;
3393 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3394 parm_data =
3395 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3396 offset);
3397 pSMB->DataOffset = cpu_to_le16(offset);
3398 parm_data->FileSize = cpu_to_le64(size);
3399 pSMB->Fid = fid;
3400 if(SetAllocation) {
3401 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3402 pSMB->InformationLevel =
3403 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3404 else
3405 pSMB->InformationLevel =
3406 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3407 } else /* Set File Size */ {
3408 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3409 pSMB->InformationLevel =
3410 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3411 else
3412 pSMB->InformationLevel =
3413 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3414 }
3415 pSMB->Reserved4 = 0;
3416 pSMB->hdr.smb_buf_length += byte_count;
3417 pSMB->ByteCount = cpu_to_le16(byte_count);
3418 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3419 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3420 if (rc) {
3421 cFYI(1,
3422 ("Send error in SetFileInfo (SetFileSize) = %d",
3423 rc));
3424 }
3425
3426 if (pSMB)
3427 cifs_buf_release(pSMB);
3428
3429 /* Note: On -EAGAIN error only caller can retry on handle based calls
3430 since file handle passed in no longer valid */
3431
3432 return rc;
3433}
3434
3435/* Some legacy servers such as NT4 require that the file times be set on
3436 an open handle, rather than by pathname - this is awkward due to
3437 potential access conflicts on the open, but it is unavoidable for these
3438 old servers since the only other choice is to go from 100 nanosecond DCE
3439 time and resort to the original setpathinfo level which takes the ancient
3440 DOS time format with 2 second granularity */
3441int
3442CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data,
3443 __u16 fid)
3444{
3445 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3446 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3447 char *data_offset;
3448 int rc = 0;
3449 int bytes_returned = 0;
3450 __u16 params, param_offset, offset, byte_count, count;
3451
3452 cFYI(1, ("Set Times (via SetFileInfo)"));
3453 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3454 (void **) &pSMBr);
3455 if (rc)
3456 return rc;
3457
3458 /* At this point there is no need to override the current pid
3459 with the pid of the opener, but that could change if we someday
3460 use an existing handle (rather than opening one on the fly) */
3461 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3462 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
3463
3464 params = 6;
3465 pSMB->MaxSetupCount = 0;
3466 pSMB->Reserved = 0;
3467 pSMB->Flags = 0;
3468 pSMB->Timeout = 0;
3469 pSMB->Reserved2 = 0;
3470 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3471 offset = param_offset + params;
3472
3473 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3474
3475 count = sizeof (FILE_BASIC_INFO);
3476 pSMB->MaxParameterCount = cpu_to_le16(2);
3477 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3478 pSMB->SetupCount = 1;
3479 pSMB->Reserved3 = 0;
3480 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3481 byte_count = 3 /* pad */ + params + count;
3482 pSMB->DataCount = cpu_to_le16(count);
3483 pSMB->ParameterCount = cpu_to_le16(params);
3484 pSMB->TotalDataCount = pSMB->DataCount;
3485 pSMB->TotalParameterCount = pSMB->ParameterCount;
3486 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3487 pSMB->DataOffset = cpu_to_le16(offset);
3488 pSMB->Fid = fid;
3489 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3490 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3491 else
3492 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3493 pSMB->Reserved4 = 0;
3494 pSMB->hdr.smb_buf_length += byte_count;
3495 pSMB->ByteCount = cpu_to_le16(byte_count);
3496 memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
3497 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3498 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3499 if (rc) {
3500 cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
3501 }
3502
3503 cifs_buf_release(pSMB);
3504
3505 /* Note: On -EAGAIN error only caller can retry on handle based calls
3506 since file handle passed in no longer valid */
3507
3508 return rc;
3509}
3510
3511
3512int
3513CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3514 const FILE_BASIC_INFO * data,
3515 const struct nls_table *nls_codepage)
3516{
3517 TRANSACTION2_SPI_REQ *pSMB = NULL;
3518 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3519 int name_len;
3520 int rc = 0;
3521 int bytes_returned = 0;
3522 char *data_offset;
3523 __u16 params, param_offset, offset, byte_count, count;
3524
3525 cFYI(1, ("In SetTimes"));
3526
3527SetTimesRetry:
3528 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3529 (void **) &pSMBr);
3530 if (rc)
3531 return rc;
3532
3533 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3534 name_len =
3535 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3536 /* find define for this maxpathcomponent */
3537 , nls_codepage);
3538 name_len++; /* trailing null */
3539 name_len *= 2;
3540 } else { /* BB improve the check for buffer overruns BB */
3541 name_len = strnlen(fileName, PATH_MAX);
3542 name_len++; /* trailing null */
3543 strncpy(pSMB->FileName, fileName, name_len);
3544 }
3545
3546 params = 6 + name_len;
3547 count = sizeof (FILE_BASIC_INFO);
3548 pSMB->MaxParameterCount = cpu_to_le16(2);
3549 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3550 pSMB->MaxSetupCount = 0;
3551 pSMB->Reserved = 0;
3552 pSMB->Flags = 0;
3553 pSMB->Timeout = 0;
3554 pSMB->Reserved2 = 0;
3555 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3556 InformationLevel) - 4;
3557 offset = param_offset + params;
3558 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3559 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3560 pSMB->DataOffset = cpu_to_le16(offset);
3561 pSMB->SetupCount = 1;
3562 pSMB->Reserved3 = 0;
3563 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3564 byte_count = 3 /* pad */ + params + count;
3565
3566 pSMB->DataCount = cpu_to_le16(count);
3567 pSMB->ParameterCount = cpu_to_le16(params);
3568 pSMB->TotalDataCount = pSMB->DataCount;
3569 pSMB->TotalParameterCount = pSMB->ParameterCount;
3570 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3571 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3572 else
3573 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3574 pSMB->Reserved4 = 0;
3575 pSMB->hdr.smb_buf_length += byte_count;
3576 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
3577 pSMB->ByteCount = cpu_to_le16(byte_count);
3578 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3579 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3580 if (rc) {
3581 cFYI(1, ("SetPathInfo (times) returned %d", rc));
3582 }
3583
3584 cifs_buf_release(pSMB);
3585
3586 if (rc == -EAGAIN)
3587 goto SetTimesRetry;
3588
3589 return rc;
3590}
3591
3592/* Can not be used to set time stamps yet (due to old DOS time format) */
3593/* Can be used to set attributes */
3594#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
3595 handling it anyway and NT4 was what we thought it would be needed for
3596 Do not delete it until we prove whether needed for Win9x though */
3597int
3598CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
3599 __u16 dos_attrs, const struct nls_table *nls_codepage)
3600{
3601 SETATTR_REQ *pSMB = NULL;
3602 SETATTR_RSP *pSMBr = NULL;
3603 int rc = 0;
3604 int bytes_returned;
3605 int name_len;
3606
3607 cFYI(1, ("In SetAttrLegacy"));
3608
3609SetAttrLgcyRetry:
3610 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
3611 (void **) &pSMBr);
3612 if (rc)
3613 return rc;
3614
3615 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3616 name_len =
3617 cifs_strtoUCS((wchar_t *) pSMB->fileName, fileName,
3618 PATH_MAX, nls_codepage);
3619 name_len++; /* trailing null */
3620 name_len *= 2;
3621 } else { /* BB improve the check for buffer overruns BB */
3622 name_len = strnlen(fileName, PATH_MAX);
3623 name_len++; /* trailing null */
3624 strncpy(pSMB->fileName, fileName, name_len);
3625 }
3626 pSMB->attr = cpu_to_le16(dos_attrs);
3627 pSMB->BufferFormat = 0x04;
3628 pSMB->hdr.smb_buf_length += name_len + 1;
3629 pSMB->ByteCount = cpu_to_le16(name_len + 1);
3630 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3631 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3632 if (rc) {
3633 cFYI(1, ("Error in LegacySetAttr = %d", rc));
3634 }
3635
3636 cifs_buf_release(pSMB);
3637
3638 if (rc == -EAGAIN)
3639 goto SetAttrLgcyRetry;
3640
3641 return rc;
3642}
3643#endif /* temporarily unneeded SetAttr legacy function */
3644
3645int
3646CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
3647 char *fileName, __u64 mode, __u64 uid, __u64 gid,
3648 dev_t device, const struct nls_table *nls_codepage)
3649{
3650 TRANSACTION2_SPI_REQ *pSMB = NULL;
3651 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3652 int name_len;
3653 int rc = 0;
3654 int bytes_returned = 0;
3655 FILE_UNIX_BASIC_INFO *data_offset;
3656 __u16 params, param_offset, offset, count, byte_count;
3657
3658 cFYI(1, ("In SetUID/GID/Mode"));
3659setPermsRetry:
3660 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3661 (void **) &pSMBr);
3662 if (rc)
3663 return rc;
3664
3665 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3666 name_len =
3667 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3668 /* find define for this maxpathcomponent */
3669 , nls_codepage);
3670 name_len++; /* trailing null */
3671 name_len *= 2;
3672 } else { /* BB improve the check for buffer overruns BB */
3673 name_len = strnlen(fileName, PATH_MAX);
3674 name_len++; /* trailing null */
3675 strncpy(pSMB->FileName, fileName, name_len);
3676 }
3677
3678 params = 6 + name_len;
3679 count = sizeof (FILE_UNIX_BASIC_INFO);
3680 pSMB->MaxParameterCount = cpu_to_le16(2);
3681 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3682 pSMB->MaxSetupCount = 0;
3683 pSMB->Reserved = 0;
3684 pSMB->Flags = 0;
3685 pSMB->Timeout = 0;
3686 pSMB->Reserved2 = 0;
3687 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3688 InformationLevel) - 4;
3689 offset = param_offset + params;
3690 data_offset =
3691 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
3692 offset);
3693 memset(data_offset, 0, count);
3694 pSMB->DataOffset = cpu_to_le16(offset);
3695 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3696 pSMB->SetupCount = 1;
3697 pSMB->Reserved3 = 0;
3698 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3699 byte_count = 3 /* pad */ + params + count;
3700 pSMB->ParameterCount = cpu_to_le16(params);
3701 pSMB->DataCount = cpu_to_le16(count);
3702 pSMB->TotalParameterCount = pSMB->ParameterCount;
3703 pSMB->TotalDataCount = pSMB->DataCount;
3704 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
3705 pSMB->Reserved4 = 0;
3706 pSMB->hdr.smb_buf_length += byte_count;
3707 data_offset->Uid = cpu_to_le64(uid);
3708 data_offset->Gid = cpu_to_le64(gid);
3709 /* better to leave device as zero when it is */
3710 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
3711 data_offset->DevMinor = cpu_to_le64(MINOR(device));
3712 data_offset->Permissions = cpu_to_le64(mode);
3713
3714 if(S_ISREG(mode))
3715 data_offset->Type = cpu_to_le32(UNIX_FILE);
3716 else if(S_ISDIR(mode))
3717 data_offset->Type = cpu_to_le32(UNIX_DIR);
3718 else if(S_ISLNK(mode))
3719 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
3720 else if(S_ISCHR(mode))
3721 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
3722 else if(S_ISBLK(mode))
3723 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
3724 else if(S_ISFIFO(mode))
3725 data_offset->Type = cpu_to_le32(UNIX_FIFO);
3726 else if(S_ISSOCK(mode))
3727 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
3728
3729
3730 pSMB->ByteCount = cpu_to_le16(byte_count);
3731 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3732 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3733 if (rc) {
3734 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
3735 }
3736
3737 if (pSMB)
3738 cifs_buf_release(pSMB);
3739 if (rc == -EAGAIN)
3740 goto setPermsRetry;
3741 return rc;
3742}
3743
3744int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
3745 const int notify_subdirs, const __u16 netfid,
3746 __u32 filter, const struct nls_table *nls_codepage)
3747{
3748 int rc = 0;
3749 struct smb_com_transaction_change_notify_req * pSMB = NULL;
3750 struct smb_com_transaction_change_notify_rsp * pSMBr = NULL;
3751 int bytes_returned;
3752
3753 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
3754 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3755 (void **) &pSMBr);
3756 if (rc)
3757 return rc;
3758
3759 pSMB->TotalParameterCount = 0 ;
3760 pSMB->TotalDataCount = 0;
3761 pSMB->MaxParameterCount = cpu_to_le32(2);
3762 /* BB find exact data count max from sess structure BB */
3763 pSMB->MaxDataCount = 0; /* same in little endian or be */
3764 pSMB->MaxSetupCount = 4;
3765 pSMB->Reserved = 0;
3766 pSMB->ParameterOffset = 0;
3767 pSMB->DataCount = 0;
3768 pSMB->DataOffset = 0;
3769 pSMB->SetupCount = 4; /* single byte does not need le conversion */
3770 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
3771 pSMB->ParameterCount = pSMB->TotalParameterCount;
3772 if(notify_subdirs)
3773 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
3774 pSMB->Reserved2 = 0;
3775 pSMB->CompletionFilter = cpu_to_le32(filter);
3776 pSMB->Fid = netfid; /* file handle always le */
3777 pSMB->ByteCount = 0;
3778
3779 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3780 (struct smb_hdr *) pSMBr, &bytes_returned, -1);
3781 if (rc) {
3782 cFYI(1, ("Error in Notify = %d", rc));
3783 }
3784 cifs_buf_release(pSMB);
3785 return rc;
3786}
3787#ifdef CONFIG_CIFS_XATTR
3788ssize_t
3789CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
3790 const unsigned char *searchName,
3791 char * EAData, size_t buf_size,
3792 const struct nls_table *nls_codepage)
3793{
3794 /* BB assumes one setup word */
3795 TRANSACTION2_QPI_REQ *pSMB = NULL;
3796 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3797 int rc = 0;
3798 int bytes_returned;
3799 int name_len;
3800 struct fea * temp_fea;
3801 char * temp_ptr;
3802 __u16 params, byte_count;
3803
3804 cFYI(1, ("In Query All EAs path %s", searchName));
3805QAllEAsRetry:
3806 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3807 (void **) &pSMBr);
3808 if (rc)
3809 return rc;
3810
3811 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3812 name_len =
3813 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
3814 /* find define for this maxpathcomponent */
3815 , nls_codepage);
3816 name_len++; /* trailing null */
3817 name_len *= 2;
3818 } else { /* BB improve the check for buffer overruns BB */
3819 name_len = strnlen(searchName, PATH_MAX);
3820 name_len++; /* trailing null */
3821 strncpy(pSMB->FileName, searchName, name_len);
3822 }
3823
3824 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3825 pSMB->TotalDataCount = 0;
3826 pSMB->MaxParameterCount = cpu_to_le16(2);
3827 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3828 pSMB->MaxSetupCount = 0;
3829 pSMB->Reserved = 0;
3830 pSMB->Flags = 0;
3831 pSMB->Timeout = 0;
3832 pSMB->Reserved2 = 0;
3833 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3834 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3835 pSMB->DataCount = 0;
3836 pSMB->DataOffset = 0;
3837 pSMB->SetupCount = 1;
3838 pSMB->Reserved3 = 0;
3839 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3840 byte_count = params + 1 /* pad */ ;
3841 pSMB->TotalParameterCount = cpu_to_le16(params);
3842 pSMB->ParameterCount = pSMB->TotalParameterCount;
3843 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3844 pSMB->Reserved4 = 0;
3845 pSMB->hdr.smb_buf_length += byte_count;
3846 pSMB->ByteCount = cpu_to_le16(byte_count);
3847
3848 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3849 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3850 if (rc) {
3851 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
3852 } else { /* decode response */
3853 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3854
3855 /* BB also check enough total bytes returned */
3856 /* BB we need to improve the validity checking
3857 of these trans2 responses */
3858 if (rc || (pSMBr->ByteCount < 4))
3859 rc = -EIO; /* bad smb */
3860 /* else if (pFindData){
3861 memcpy((char *) pFindData,
3862 (char *) &pSMBr->hdr.Protocol +
3863 data_offset, kl);
3864 }*/ else {
3865 /* check that length of list is not more than bcc */
3866 /* check that each entry does not go beyond length
3867 of list */
3868 /* check that each element of each entry does not
3869 go beyond end of list */
3870 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3871 struct fealist * ea_response_data;
3872 rc = 0;
3873 /* validate_trans2_offsets() */
3874 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
3875 ea_response_data = (struct fealist *)
3876 (((char *) &pSMBr->hdr.Protocol) +
3877 data_offset);
3878 name_len = le32_to_cpu(ea_response_data->list_len);
3879 cFYI(1,("ea length %d", name_len));
3880 if(name_len <= 8) {
3881 /* returned EA size zeroed at top of function */
3882 cFYI(1,("empty EA list returned from server"));
3883 } else {
3884 /* account for ea list len */
3885 name_len -= 4;
3886 temp_fea = ea_response_data->list;
3887 temp_ptr = (char *)temp_fea;
3888 while(name_len > 0) {
3889 __u16 value_len;
3890 name_len -= 4;
3891 temp_ptr += 4;
3892 rc += temp_fea->name_len;
3893 /* account for prefix user. and trailing null */
3894 rc = rc + 5 + 1;
3895 if(rc<(int)buf_size) {
3896 memcpy(EAData,"user.",5);
3897 EAData+=5;
3898 memcpy(EAData,temp_ptr,temp_fea->name_len);
3899 EAData+=temp_fea->name_len;
3900 /* null terminate name */
3901 *EAData = 0;
3902 EAData = EAData + 1;
3903 } else if(buf_size == 0) {
3904 /* skip copy - calc size only */
3905 } else {
3906 /* stop before overrun buffer */
3907 rc = -ERANGE;
3908 break;
3909 }
3910 name_len -= temp_fea->name_len;
3911 temp_ptr += temp_fea->name_len;
3912 /* account for trailing null */
3913 name_len--;
3914 temp_ptr++;
3915 value_len = le16_to_cpu(temp_fea->value_len);
3916 name_len -= value_len;
3917 temp_ptr += value_len;
3918 /* BB check that temp_ptr is still within smb BB*/
3919 /* no trailing null to account for in value len */
3920 /* go on to next EA */
3921 temp_fea = (struct fea *)temp_ptr;
3922 }
3923 }
3924 }
3925 }
3926 if (pSMB)
3927 cifs_buf_release(pSMB);
3928 if (rc == -EAGAIN)
3929 goto QAllEAsRetry;
3930
3931 return (ssize_t)rc;
3932}
3933
3934ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
3935 const unsigned char * searchName,const unsigned char * ea_name,
3936 unsigned char * ea_value, size_t buf_size,
3937 const struct nls_table *nls_codepage)
3938{
3939 TRANSACTION2_QPI_REQ *pSMB = NULL;
3940 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3941 int rc = 0;
3942 int bytes_returned;
3943 int name_len;
3944 struct fea * temp_fea;
3945 char * temp_ptr;
3946 __u16 params, byte_count;
3947
3948 cFYI(1, ("In Query EA path %s", searchName));
3949QEARetry:
3950 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3951 (void **) &pSMBr);
3952 if (rc)
3953 return rc;
3954
3955 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3956 name_len =
3957 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
3958 /* find define for this maxpathcomponent */
3959 , nls_codepage);
3960 name_len++; /* trailing null */
3961 name_len *= 2;
3962 } else { /* BB improve the check for buffer overruns BB */
3963 name_len = strnlen(searchName, PATH_MAX);
3964 name_len++; /* trailing null */
3965 strncpy(pSMB->FileName, searchName, name_len);
3966 }
3967
3968 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3969 pSMB->TotalDataCount = 0;
3970 pSMB->MaxParameterCount = cpu_to_le16(2);
3971 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3972 pSMB->MaxSetupCount = 0;
3973 pSMB->Reserved = 0;
3974 pSMB->Flags = 0;
3975 pSMB->Timeout = 0;
3976 pSMB->Reserved2 = 0;
3977 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3978 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3979 pSMB->DataCount = 0;
3980 pSMB->DataOffset = 0;
3981 pSMB->SetupCount = 1;
3982 pSMB->Reserved3 = 0;
3983 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3984 byte_count = params + 1 /* pad */ ;
3985 pSMB->TotalParameterCount = cpu_to_le16(params);
3986 pSMB->ParameterCount = pSMB->TotalParameterCount;
3987 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3988 pSMB->Reserved4 = 0;
3989 pSMB->hdr.smb_buf_length += byte_count;
3990 pSMB->ByteCount = cpu_to_le16(byte_count);
3991
3992 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3993 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3994 if (rc) {
3995 cFYI(1, ("Send error in Query EA = %d", rc));
3996 } else { /* decode response */
3997 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3998
3999 /* BB also check enough total bytes returned */
4000 /* BB we need to improve the validity checking
4001 of these trans2 responses */
4002 if (rc || (pSMBr->ByteCount < 4))
4003 rc = -EIO; /* bad smb */
4004 /* else if (pFindData){
4005 memcpy((char *) pFindData,
4006 (char *) &pSMBr->hdr.Protocol +
4007 data_offset, kl);
4008 }*/ else {
4009 /* check that length of list is not more than bcc */
4010 /* check that each entry does not go beyond length
4011 of list */
4012 /* check that each element of each entry does not
4013 go beyond end of list */
4014 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4015 struct fealist * ea_response_data;
4016 rc = -ENODATA;
4017 /* validate_trans2_offsets() */
4018 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4019 ea_response_data = (struct fealist *)
4020 (((char *) &pSMBr->hdr.Protocol) +
4021 data_offset);
4022 name_len = le32_to_cpu(ea_response_data->list_len);
4023 cFYI(1,("ea length %d", name_len));
4024 if(name_len <= 8) {
4025 /* returned EA size zeroed at top of function */
4026 cFYI(1,("empty EA list returned from server"));
4027 } else {
4028 /* account for ea list len */
4029 name_len -= 4;
4030 temp_fea = ea_response_data->list;
4031 temp_ptr = (char *)temp_fea;
4032 /* loop through checking if we have a matching
4033 name and then return the associated value */
4034 while(name_len > 0) {
4035 __u16 value_len;
4036 name_len -= 4;
4037 temp_ptr += 4;
4038 value_len = le16_to_cpu(temp_fea->value_len);
4039 /* BB validate that value_len falls within SMB,
4040 even though maximum for name_len is 255 */
4041 if(memcmp(temp_fea->name,ea_name,
4042 temp_fea->name_len) == 0) {
4043 /* found a match */
4044 rc = value_len;
4045 /* account for prefix user. and trailing null */
4046 if(rc<=(int)buf_size) {
4047 memcpy(ea_value,
4048 temp_fea->name+temp_fea->name_len+1,
4049 rc);
4050 /* ea values, unlike ea names,
4051 are not null terminated */
4052 } else if(buf_size == 0) {
4053 /* skip copy - calc size only */
4054 } else {
4055 /* stop before overrun buffer */
4056 rc = -ERANGE;
4057 }
4058 break;
4059 }
4060 name_len -= temp_fea->name_len;
4061 temp_ptr += temp_fea->name_len;
4062 /* account for trailing null */
4063 name_len--;
4064 temp_ptr++;
4065 name_len -= value_len;
4066 temp_ptr += value_len;
4067 /* no trailing null to account for in value len */
4068 /* go on to next EA */
4069 temp_fea = (struct fea *)temp_ptr;
4070 }
4071 }
4072 }
4073 }
4074 if (pSMB)
4075 cifs_buf_release(pSMB);
4076 if (rc == -EAGAIN)
4077 goto QEARetry;
4078
4079 return (ssize_t)rc;
4080}
4081
4082int
4083CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4084 const char * ea_name, const void * ea_value,
4085 const __u16 ea_value_len, const struct nls_table *nls_codepage)
4086{
4087 struct smb_com_transaction2_spi_req *pSMB = NULL;
4088 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4089 struct fealist *parm_data;
4090 int name_len;
4091 int rc = 0;
4092 int bytes_returned = 0;
4093 __u16 params, param_offset, byte_count, offset, count;
4094
4095 cFYI(1, ("In SetEA"));
4096SetEARetry:
4097 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4098 (void **) &pSMBr);
4099 if (rc)
4100 return rc;
4101
4102 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4103 name_len =
4104 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
4105 /* find define for this maxpathcomponent */
4106 , nls_codepage);
4107 name_len++; /* trailing null */
4108 name_len *= 2;
4109 } else { /* BB improve the check for buffer overruns BB */
4110 name_len = strnlen(fileName, PATH_MAX);
4111 name_len++; /* trailing null */
4112 strncpy(pSMB->FileName, fileName, name_len);
4113 }
4114
4115 params = 6 + name_len;
4116
4117 /* done calculating parms using name_len of file name,
4118 now use name_len to calculate length of ea name
4119 we are going to create in the inode xattrs */
4120 if(ea_name == NULL)
4121 name_len = 0;
4122 else
4123 name_len = strnlen(ea_name,255);
4124
4125 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
4126 pSMB->MaxParameterCount = cpu_to_le16(2);
4127 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
4128 pSMB->MaxSetupCount = 0;
4129 pSMB->Reserved = 0;
4130 pSMB->Flags = 0;
4131 pSMB->Timeout = 0;
4132 pSMB->Reserved2 = 0;
4133 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4134 InformationLevel) - 4;
4135 offset = param_offset + params;
4136 pSMB->InformationLevel =
4137 cpu_to_le16(SMB_SET_FILE_EA);
4138
4139 parm_data =
4140 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
4141 offset);
4142 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4143 pSMB->DataOffset = cpu_to_le16(offset);
4144 pSMB->SetupCount = 1;
4145 pSMB->Reserved3 = 0;
4146 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4147 byte_count = 3 /* pad */ + params + count;
4148 pSMB->DataCount = cpu_to_le16(count);
4149 parm_data->list_len = cpu_to_le32(count);
4150 parm_data->list[0].EA_flags = 0;
4151 /* we checked above that name len is less than 255 */
4152 parm_data->list[0].name_len = (__u8)name_len;;
4153 /* EA names are always ASCII */
4154 if(ea_name)
4155 strncpy(parm_data->list[0].name,ea_name,name_len);
4156 parm_data->list[0].name[name_len] = 0;
4157 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
4158 /* caller ensures that ea_value_len is less than 64K but
4159 we need to ensure that it fits within the smb */
4160
4161 /*BB add length check that it would fit in negotiated SMB buffer size BB */
4162 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
4163 if(ea_value_len)
4164 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
4165
4166 pSMB->TotalDataCount = pSMB->DataCount;
4167 pSMB->ParameterCount = cpu_to_le16(params);
4168 pSMB->TotalParameterCount = pSMB->ParameterCount;
4169 pSMB->Reserved4 = 0;
4170 pSMB->hdr.smb_buf_length += byte_count;
4171 pSMB->ByteCount = cpu_to_le16(byte_count);
4172 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4173 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4174 if (rc) {
4175 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
4176 }
4177
4178 cifs_buf_release(pSMB);
4179
4180 if (rc == -EAGAIN)
4181 goto SetEARetry;
4182
4183 return rc;
4184}
4185
4186#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-19 10:39:06 -0500