blob: 36d3c128a58bde9166e94cab813ef3314ea28926 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Steve Frenchf654bac2005-04-28 22:41:04 -07002075/* BB fix tabs in this function FIXME BB */
2076int
2077CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2078 const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
2079{
2080 int rc = 0;
2081 struct smb_t2_qfi_req *pSMB = NULL;
2082 struct smb_t2_qfi_rsp *pSMBr = NULL;
2083 int bytes_returned;
2084 __u16 params, byte_count;
2085
2086 cFYI(1,("In GetExtAttr"));
2087 if(tcon == NULL)
2088 return -ENODEV;
2089
2090GetExtAttrRetry:
2091 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2092 (void **) &pSMBr);
2093 if (rc)
2094 return rc;
2095
2096 params = 2 /* level */ +2 /* fid */ + 2 /* rsrvd */;
2097 pSMB->t2.TotalDataCount = 0;
2098 pSMB->t2.MaxParameterCount = cpu_to_le16(2);
2099 /* BB find exact max data count below from sess structure BB */
2100 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
2101 pSMB->t2.MaxSetupCount = 0;
2102 pSMB->t2.Reserved = 0;
2103 pSMB->t2.Flags = 0;
2104 pSMB->t2.Timeout = 0;
2105 pSMB->t2.Reserved2 = 0;
2106 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(
2107 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2108 pSMB->t2.DataCount = 0;
2109 pSMB->t2.DataOffset = 0;
2110 pSMB->t2.SetupCount = 1;
2111 pSMB->t2.Reserved3 = 0;
2112 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2113 byte_count = params + 3 /* pad */ ;
2114 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
2115 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
2116 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
2117 pSMB->Pad1 = 0;
2118 pSMB->Pad2 = 0;
2119 pSMB->Fid = netfid;
2120 pSMB->hdr.smb_buf_length += byte_count;
2121 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
2122
2123 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2124 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2125 if (rc) {
2126 cFYI(1, ("error %d in GetExtAttr", rc));
2127 } else {
2128 /* decode response */
2129 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2130 if (rc || (pSMBr->ByteCount < 2))
2131 /* BB also check enough total bytes returned */
2132 /* If rc should we check for EOPNOSUPP and
2133 disable the srvino flag? or in caller? */
2134 rc = -EIO; /* bad smb */
2135 else {
2136 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2137 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2138 struct file_chattr_info * pfinfo;
2139 /* BB Do we need a cast or hash here ? */
2140 if(count != 16) {
2141 cFYI(1, ("Illegal size ret in GetExtAttr"));
2142 rc = -EIO;
2143 goto GetExtAttrOut;
2144 }
2145 pfinfo = (struct file_chattr_info *)
2146 (data_offset + (char *) &pSMBr->hdr.Protocol);
2147 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
2148 *pMask = le64_to_cpu(pfinfo->mask);
2149 }
2150 }
2151GetExtAttrOut:
2152 cifs_buf_release(pSMB);
2153 if (rc == -EAGAIN)
2154 goto GetExtAttrRetry;
2155 return rc;
2156}
2157
2158
2159#endif /* CONFIG_POSIX */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160
2161int
2162CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
2163 const unsigned char *searchName,
2164 FILE_ALL_INFO * pFindData,
2165 const struct nls_table *nls_codepage)
2166{
2167/* level 263 SMB_QUERY_FILE_ALL_INFO */
2168 TRANSACTION2_QPI_REQ *pSMB = NULL;
2169 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2170 int rc = 0;
2171 int bytes_returned;
2172 int name_len;
2173 __u16 params, byte_count;
2174
2175/* cFYI(1, ("In QPathInfo path %s", searchName)); */
2176QPathInfoRetry:
2177 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2178 (void **) &pSMBr);
2179 if (rc)
2180 return rc;
2181
2182 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2183 name_len =
2184 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2185 /* find define for this maxpathcomponent */
2186 , nls_codepage);
2187 name_len++; /* trailing null */
2188 name_len *= 2;
2189 } else { /* BB improve the check for buffer overruns BB */
2190 name_len = strnlen(searchName, PATH_MAX);
2191 name_len++; /* trailing null */
2192 strncpy(pSMB->FileName, searchName, name_len);
2193 }
2194
2195 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2196 pSMB->TotalDataCount = 0;
2197 pSMB->MaxParameterCount = cpu_to_le16(2);
2198 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2199 pSMB->MaxSetupCount = 0;
2200 pSMB->Reserved = 0;
2201 pSMB->Flags = 0;
2202 pSMB->Timeout = 0;
2203 pSMB->Reserved2 = 0;
2204 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2205 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2206 pSMB->DataCount = 0;
2207 pSMB->DataOffset = 0;
2208 pSMB->SetupCount = 1;
2209 pSMB->Reserved3 = 0;
2210 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2211 byte_count = params + 1 /* pad */ ;
2212 pSMB->TotalParameterCount = cpu_to_le16(params);
2213 pSMB->ParameterCount = pSMB->TotalParameterCount;
2214 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
2215 pSMB->Reserved4 = 0;
2216 pSMB->hdr.smb_buf_length += byte_count;
2217 pSMB->ByteCount = cpu_to_le16(byte_count);
2218
2219 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2220 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2221 if (rc) {
2222 cFYI(1, ("Send error in QPathInfo = %d", rc));
2223 } else { /* decode response */
2224 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2225
2226 if (rc || (pSMBr->ByteCount < 40))
2227 rc = -EIO; /* bad smb */
2228 else if (pFindData){
2229 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2230 memcpy((char *) pFindData,
2231 (char *) &pSMBr->hdr.Protocol +
2232 data_offset, sizeof (FILE_ALL_INFO));
2233 } else
2234 rc = -ENOMEM;
2235 }
2236 cifs_buf_release(pSMB);
2237 if (rc == -EAGAIN)
2238 goto QPathInfoRetry;
2239
2240 return rc;
2241}
2242
2243int
2244CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
2245 const unsigned char *searchName,
2246 FILE_UNIX_BASIC_INFO * pFindData,
2247 const struct nls_table *nls_codepage)
2248{
2249/* SMB_QUERY_FILE_UNIX_BASIC */
2250 TRANSACTION2_QPI_REQ *pSMB = NULL;
2251 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2252 int rc = 0;
2253 int bytes_returned = 0;
2254 int name_len;
2255 __u16 params, byte_count;
2256
2257 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
2258UnixQPathInfoRetry:
2259 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2260 (void **) &pSMBr);
2261 if (rc)
2262 return rc;
2263
2264 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2265 name_len =
2266 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2267 /* find define for this maxpathcomponent */
2268 , nls_codepage);
2269 name_len++; /* trailing null */
2270 name_len *= 2;
2271 } else { /* BB improve the check for buffer overruns BB */
2272 name_len = strnlen(searchName, PATH_MAX);
2273 name_len++; /* trailing null */
2274 strncpy(pSMB->FileName, searchName, name_len);
2275 }
2276
2277 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2278 pSMB->TotalDataCount = 0;
2279 pSMB->MaxParameterCount = cpu_to_le16(2);
2280 /* BB find exact max SMB PDU from sess structure BB */
2281 pSMB->MaxDataCount = cpu_to_le16(4000);
2282 pSMB->MaxSetupCount = 0;
2283 pSMB->Reserved = 0;
2284 pSMB->Flags = 0;
2285 pSMB->Timeout = 0;
2286 pSMB->Reserved2 = 0;
2287 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2288 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2289 pSMB->DataCount = 0;
2290 pSMB->DataOffset = 0;
2291 pSMB->SetupCount = 1;
2292 pSMB->Reserved3 = 0;
2293 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2294 byte_count = params + 1 /* pad */ ;
2295 pSMB->TotalParameterCount = cpu_to_le16(params);
2296 pSMB->ParameterCount = pSMB->TotalParameterCount;
2297 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
2298 pSMB->Reserved4 = 0;
2299 pSMB->hdr.smb_buf_length += byte_count;
2300 pSMB->ByteCount = cpu_to_le16(byte_count);
2301
2302 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2303 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2304 if (rc) {
2305 cFYI(1, ("Send error in QPathInfo = %d", rc));
2306 } else { /* decode response */
2307 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2308
2309 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
2310 rc = -EIO; /* bad smb */
2311 } else {
2312 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2313 memcpy((char *) pFindData,
2314 (char *) &pSMBr->hdr.Protocol +
2315 data_offset,
2316 sizeof (FILE_UNIX_BASIC_INFO));
2317 }
2318 }
2319 cifs_buf_release(pSMB);
2320 if (rc == -EAGAIN)
2321 goto UnixQPathInfoRetry;
2322
2323 return rc;
2324}
2325
2326#if 0 /* function unused at present */
2327int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
2328 const char *searchName, FILE_ALL_INFO * findData,
2329 const struct nls_table *nls_codepage)
2330{
2331/* level 257 SMB_ */
2332 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2333 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2334 int rc = 0;
2335 int bytes_returned;
2336 int name_len;
2337 __u16 params, byte_count;
2338
2339 cFYI(1, ("In FindUnique"));
2340findUniqueRetry:
2341 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2342 (void **) &pSMBr);
2343 if (rc)
2344 return rc;
2345
2346 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2347 name_len =
2348 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
2349 /* find define for this maxpathcomponent */
2350 , nls_codepage);
2351 name_len++; /* trailing null */
2352 name_len *= 2;
2353 } else { /* BB improve the check for buffer overruns BB */
2354 name_len = strnlen(searchName, PATH_MAX);
2355 name_len++; /* trailing null */
2356 strncpy(pSMB->FileName, searchName, name_len);
2357 }
2358
2359 params = 12 + name_len /* includes null */ ;
2360 pSMB->TotalDataCount = 0; /* no EAs */
2361 pSMB->MaxParameterCount = cpu_to_le16(2);
2362 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2363 pSMB->MaxSetupCount = 0;
2364 pSMB->Reserved = 0;
2365 pSMB->Flags = 0;
2366 pSMB->Timeout = 0;
2367 pSMB->Reserved2 = 0;
2368 pSMB->ParameterOffset = cpu_to_le16(
2369 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
2370 pSMB->DataCount = 0;
2371 pSMB->DataOffset = 0;
2372 pSMB->SetupCount = 1; /* one byte, no need to le convert */
2373 pSMB->Reserved3 = 0;
2374 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2375 byte_count = params + 1 /* pad */ ;
2376 pSMB->TotalParameterCount = cpu_to_le16(params);
2377 pSMB->ParameterCount = pSMB->TotalParameterCount;
2378 pSMB->SearchAttributes =
2379 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2380 ATTR_DIRECTORY);
2381 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
2382 pSMB->SearchFlags = cpu_to_le16(1);
2383 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2384 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
2385 pSMB->hdr.smb_buf_length += byte_count;
2386 pSMB->ByteCount = cpu_to_le16(byte_count);
2387
2388 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2389 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2390
2391 if (rc) {
2392 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
2393 } else { /* decode response */
2394
2395 /* BB fill in */
2396 }
2397
2398 cifs_buf_release(pSMB);
2399 if (rc == -EAGAIN)
2400 goto findUniqueRetry;
2401
2402 return rc;
2403}
2404#endif /* end unused (temporarily) function */
2405
2406/* xid, tcon, searchName and codepage are input parms, rest are returned */
2407int
2408CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
2409 const char *searchName,
2410 const struct nls_table *nls_codepage,
2411 __u16 * pnetfid,
2412 struct cifs_search_info * psrch_inf)
2413{
2414/* level 257 SMB_ */
2415 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2416 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2417 T2_FFIRST_RSP_PARMS * parms;
2418 int rc = 0;
2419 int bytes_returned = 0;
2420 int name_len;
2421 __u16 params, byte_count;
2422
2423 cFYI(1, ("In FindFirst"));
2424
2425findFirstRetry:
2426 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2427 (void **) &pSMBr);
2428 if (rc)
2429 return rc;
2430
2431 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2432 name_len =
2433 cifs_strtoUCS((wchar_t *) pSMB->FileName,searchName,
2434 PATH_MAX, nls_codepage);
2435 name_len++; /* trailing null */
2436 name_len *= 2;
2437 pSMB->FileName[name_len] = 0; /* null terminate just in case */
2438 pSMB->FileName[name_len+1] = 0;
2439 } else { /* BB add check for overrun of SMB buf BB */
2440 name_len = strnlen(searchName, PATH_MAX);
2441 name_len++; /* trailing null */
2442/* BB fix here and in unicode clause above ie
2443 if(name_len > buffersize-header)
2444 free buffer exit; BB */
2445 strncpy(pSMB->FileName, searchName, name_len);
2446 pSMB->FileName[name_len] = 0; /* just in case */
2447 }
2448
2449 params = 12 + name_len /* includes null */ ;
2450 pSMB->TotalDataCount = 0; /* no EAs */
2451 pSMB->MaxParameterCount = cpu_to_le16(10);
2452 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
2453 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2454 pSMB->MaxSetupCount = 0;
2455 pSMB->Reserved = 0;
2456 pSMB->Flags = 0;
2457 pSMB->Timeout = 0;
2458 pSMB->Reserved2 = 0;
2459 byte_count = params + 1 /* pad */ ;
2460 pSMB->TotalParameterCount = cpu_to_le16(params);
2461 pSMB->ParameterCount = pSMB->TotalParameterCount;
2462 pSMB->ParameterOffset = cpu_to_le16(
2463 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
2464 pSMB->DataCount = 0;
2465 pSMB->DataOffset = 0;
2466 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
2467 pSMB->Reserved3 = 0;
2468 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2469 pSMB->SearchAttributes =
2470 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2471 ATTR_DIRECTORY);
2472 pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
2473 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
2474 CIFS_SEARCH_RETURN_RESUME);
2475 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2476
2477 /* BB what should we set StorageType to? Does it matter? BB */
2478 pSMB->SearchStorageType = 0;
2479 pSMB->hdr.smb_buf_length += byte_count;
2480 pSMB->ByteCount = cpu_to_le16(byte_count);
2481
2482 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2483 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2484
2485 if (rc) {/* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
2486 /* BB Add code to handle unsupported level rc */
2487 cFYI(1, ("Error in FindFirst = %d", rc));
2488
2489 if (pSMB)
2490 cifs_buf_release(pSMB);
2491
2492 /* BB eventually could optimize out free and realloc of buf */
2493 /* for this case */
2494 if (rc == -EAGAIN)
2495 goto findFirstRetry;
2496 } else { /* decode response */
2497 /* BB remember to free buffer if error BB */
2498 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2499 if(rc == 0) {
2500 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2501 psrch_inf->unicode = TRUE;
2502 else
2503 psrch_inf->unicode = FALSE;
2504
2505 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
2506 psrch_inf->srch_entries_start =
2507 (char *) &pSMBr->hdr.Protocol +
2508 le16_to_cpu(pSMBr->t2.DataOffset);
2509
2510 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
2511 le16_to_cpu(pSMBr->t2.ParameterOffset));
2512
2513 if(parms->EndofSearch)
2514 psrch_inf->endOfSearch = TRUE;
2515 else
2516 psrch_inf->endOfSearch = FALSE;
2517
2518 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2519 psrch_inf->index_of_last_entry =
2520 psrch_inf->entries_in_buffer;
2521/*cFYI(1,("entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
2522 *pnetfid = parms->SearchHandle;
2523 } else {
2524 cifs_buf_release(pSMB);
2525 }
2526 }
2527
2528 return rc;
2529}
2530
2531int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
2532 __u16 searchHandle, struct cifs_search_info * psrch_inf)
2533{
2534 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
2535 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
2536 T2_FNEXT_RSP_PARMS * parms;
2537 char *response_data;
2538 int rc = 0;
2539 int bytes_returned, name_len;
2540 __u16 params, byte_count;
2541
2542 cFYI(1, ("In FindNext"));
2543
2544 if(psrch_inf->endOfSearch == TRUE)
2545 return -ENOENT;
2546
2547 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2548 (void **) &pSMBr);
2549 if (rc)
2550 return rc;
2551
2552 params = 14; /* includes 2 bytes of null string, converted to LE below */
2553 byte_count = 0;
2554 pSMB->TotalDataCount = 0; /* no EAs */
2555 pSMB->MaxParameterCount = cpu_to_le16(8);
2556 pSMB->MaxDataCount =
2557 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2558 pSMB->MaxSetupCount = 0;
2559 pSMB->Reserved = 0;
2560 pSMB->Flags = 0;
2561 pSMB->Timeout = 0;
2562 pSMB->Reserved2 = 0;
2563 pSMB->ParameterOffset = cpu_to_le16(
2564 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
2565 pSMB->DataCount = 0;
2566 pSMB->DataOffset = 0;
2567 pSMB->SetupCount = 1;
2568 pSMB->Reserved3 = 0;
2569 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
2570 pSMB->SearchHandle = searchHandle; /* always kept as le */
2571 pSMB->SearchCount =
2572 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
2573 /* test for Unix extensions */
2574/* if (tcon->ses->capabilities & CAP_UNIX) {
2575 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
2576 psrch_inf->info_level = SMB_FIND_FILE_UNIX;
2577 } else {
2578 pSMB->InformationLevel =
2579 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2580 psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
2581 } */
2582 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2583 pSMB->ResumeKey = psrch_inf->resume_key;
2584 pSMB->SearchFlags =
2585 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
2586
2587 name_len = psrch_inf->resume_name_len;
2588 params += name_len;
2589 if(name_len < PATH_MAX) {
2590 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
2591 byte_count += name_len;
2592 } else {
2593 rc = -EINVAL;
2594 goto FNext2_err_exit;
2595 }
2596 byte_count = params + 1 /* pad */ ;
2597 pSMB->TotalParameterCount = cpu_to_le16(params);
2598 pSMB->ParameterCount = pSMB->TotalParameterCount;
2599 pSMB->hdr.smb_buf_length += byte_count;
2600 pSMB->ByteCount = cpu_to_le16(byte_count);
2601
2602 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2603 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2604
2605 if (rc) {
2606 if (rc == -EBADF) {
2607 psrch_inf->endOfSearch = TRUE;
2608 rc = 0; /* search probably was closed at end of search above */
2609 } else
2610 cFYI(1, ("FindNext returned = %d", rc));
2611 } else { /* decode response */
2612 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2613
2614 if(rc == 0) {
2615 /* BB fixme add lock for file (srch_info) struct here */
2616 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2617 psrch_inf->unicode = TRUE;
2618 else
2619 psrch_inf->unicode = FALSE;
2620 response_data = (char *) &pSMBr->hdr.Protocol +
2621 le16_to_cpu(pSMBr->t2.ParameterOffset);
2622 parms = (T2_FNEXT_RSP_PARMS *)response_data;
2623 response_data = (char *)&pSMBr->hdr.Protocol +
2624 le16_to_cpu(pSMBr->t2.DataOffset);
2625 cifs_buf_release(psrch_inf->ntwrk_buf_start);
2626 psrch_inf->srch_entries_start = response_data;
2627 psrch_inf->ntwrk_buf_start = (char *)pSMB;
2628 if(parms->EndofSearch)
2629 psrch_inf->endOfSearch = TRUE;
2630 else
2631 psrch_inf->endOfSearch = FALSE;
2632
2633 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2634 psrch_inf->index_of_last_entry +=
2635 psrch_inf->entries_in_buffer;
2636/* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
2637
2638 /* BB fixme add unlock here */
2639 }
2640
2641 }
2642
2643 /* BB On error, should we leave previous search buf (and count and
2644 last entry fields) intact or free the previous one? */
2645
2646 /* Note: On -EAGAIN error only caller can retry on handle based calls
2647 since file handle passed in no longer valid */
2648FNext2_err_exit:
2649 if (rc != 0)
2650 cifs_buf_release(pSMB);
2651
2652 return rc;
2653}
2654
2655int
2656CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
2657{
2658 int rc = 0;
2659 FINDCLOSE_REQ *pSMB = NULL;
2660 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
2661 int bytes_returned;
2662
2663 cFYI(1, ("In CIFSSMBFindClose"));
2664 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
2665
2666 /* no sense returning error if session restarted
2667 as file handle has been closed */
2668 if(rc == -EAGAIN)
2669 return 0;
2670 if (rc)
2671 return rc;
2672
2673 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
2674 pSMB->FileID = searchHandle;
2675 pSMB->ByteCount = 0;
2676 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2677 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2678 if (rc) {
2679 cERROR(1, ("Send error in FindClose = %d", rc));
2680 }
2681 cifs_small_buf_release(pSMB);
2682
2683 /* Since session is dead, search handle closed on server already */
2684 if (rc == -EAGAIN)
2685 rc = 0;
2686
2687 return rc;
2688}
2689
2690#ifdef CONFIG_CIFS_EXPERIMENTAL
2691int
2692CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
2693 const unsigned char *searchName,
2694 __u64 * inode_number,
2695 const struct nls_table *nls_codepage)
2696{
2697 int rc = 0;
2698 TRANSACTION2_QPI_REQ *pSMB = NULL;
2699 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2700 int name_len, bytes_returned;
2701 __u16 params, byte_count;
2702
2703 cFYI(1,("In GetSrvInodeNum for %s",searchName));
2704 if(tcon == NULL)
2705 return -ENODEV;
2706
2707GetInodeNumberRetry:
2708 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2709 (void **) &pSMBr);
2710 if (rc)
2711 return rc;
2712
2713
2714 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2715 name_len =
2716 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName,
2717 PATH_MAX,nls_codepage);
2718 name_len++; /* trailing null */
2719 name_len *= 2;
2720 } else { /* BB improve the check for buffer overruns BB */
2721 name_len = strnlen(searchName, PATH_MAX);
2722 name_len++; /* trailing null */
2723 strncpy(pSMB->FileName, searchName, name_len);
2724 }
2725
2726 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2727 pSMB->TotalDataCount = 0;
2728 pSMB->MaxParameterCount = cpu_to_le16(2);
2729 /* BB find exact max data count below from sess structure BB */
2730 pSMB->MaxDataCount = cpu_to_le16(4000);
2731 pSMB->MaxSetupCount = 0;
2732 pSMB->Reserved = 0;
2733 pSMB->Flags = 0;
2734 pSMB->Timeout = 0;
2735 pSMB->Reserved2 = 0;
2736 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2737 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2738 pSMB->DataCount = 0;
2739 pSMB->DataOffset = 0;
2740 pSMB->SetupCount = 1;
2741 pSMB->Reserved3 = 0;
2742 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2743 byte_count = params + 1 /* pad */ ;
2744 pSMB->TotalParameterCount = cpu_to_le16(params);
2745 pSMB->ParameterCount = pSMB->TotalParameterCount;
2746 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
2747 pSMB->Reserved4 = 0;
2748 pSMB->hdr.smb_buf_length += byte_count;
2749 pSMB->ByteCount = cpu_to_le16(byte_count);
2750
2751 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2752 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2753 if (rc) {
2754 cFYI(1, ("error %d in QueryInternalInfo", rc));
2755 } else {
2756 /* decode response */
2757 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2758 if (rc || (pSMBr->ByteCount < 2))
2759 /* BB also check enough total bytes returned */
2760 /* If rc should we check for EOPNOSUPP and
2761 disable the srvino flag? or in caller? */
2762 rc = -EIO; /* bad smb */
2763 else {
2764 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2765 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2766 struct file_internal_info * pfinfo;
2767 /* BB Do we need a cast or hash here ? */
2768 if(count < 8) {
2769 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
2770 rc = -EIO;
2771 goto GetInodeNumOut;
2772 }
2773 pfinfo = (struct file_internal_info *)
2774 (data_offset + (char *) &pSMBr->hdr.Protocol);
2775 *inode_number = pfinfo->UniqueId;
2776 }
2777 }
2778GetInodeNumOut:
2779 cifs_buf_release(pSMB);
2780 if (rc == -EAGAIN)
2781 goto GetInodeNumberRetry;
2782 return rc;
2783}
2784#endif /* CIFS_EXPERIMENTAL */
2785
2786int
2787CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
2788 const unsigned char *searchName,
2789 unsigned char **targetUNCs,
2790 unsigned int *number_of_UNC_in_array,
2791 const struct nls_table *nls_codepage)
2792{
2793/* TRANS2_GET_DFS_REFERRAL */
2794 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
2795 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
2796 struct dfs_referral_level_3 * referrals = NULL;
2797 int rc = 0;
2798 int bytes_returned;
2799 int name_len;
2800 unsigned int i;
2801 char * temp;
2802 __u16 params, byte_count;
2803 *number_of_UNC_in_array = 0;
2804 *targetUNCs = NULL;
2805
2806 cFYI(1, ("In GetDFSRefer the path %s", searchName));
2807 if (ses == NULL)
2808 return -ENODEV;
2809getDFSRetry:
2810 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
2811 (void **) &pSMBr);
2812 if (rc)
2813 return rc;
2814
2815 pSMB->hdr.Tid = ses->ipc_tid;
2816 pSMB->hdr.Uid = ses->Suid;
2817 if (ses->capabilities & CAP_STATUS32) {
2818 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
2819 }
2820 if (ses->capabilities & CAP_DFS) {
2821 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
2822 }
2823
2824 if (ses->capabilities & CAP_UNICODE) {
2825 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
2826 name_len =
2827 cifs_strtoUCS((wchar_t *) pSMB->RequestFileName,
2828 searchName, PATH_MAX
2829 /* find define for this maxpathcomponent */
2830 , nls_codepage);
2831 name_len++; /* trailing null */
2832 name_len *= 2;
2833 } else { /* BB improve the check for buffer overruns BB */
2834 name_len = strnlen(searchName, PATH_MAX);
2835 name_len++; /* trailing null */
2836 strncpy(pSMB->RequestFileName, searchName, name_len);
2837 }
2838
2839 params = 2 /* level */ + name_len /*includes null */ ;
2840 pSMB->TotalDataCount = 0;
2841 pSMB->DataCount = 0;
2842 pSMB->DataOffset = 0;
2843 pSMB->MaxParameterCount = 0;
2844 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2845 pSMB->MaxSetupCount = 0;
2846 pSMB->Reserved = 0;
2847 pSMB->Flags = 0;
2848 pSMB->Timeout = 0;
2849 pSMB->Reserved2 = 0;
2850 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2851 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
2852 pSMB->SetupCount = 1;
2853 pSMB->Reserved3 = 0;
2854 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
2855 byte_count = params + 3 /* pad */ ;
2856 pSMB->ParameterCount = cpu_to_le16(params);
2857 pSMB->TotalParameterCount = pSMB->ParameterCount;
2858 pSMB->MaxReferralLevel = cpu_to_le16(3);
2859 pSMB->hdr.smb_buf_length += byte_count;
2860 pSMB->ByteCount = cpu_to_le16(byte_count);
2861
2862 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
2863 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2864 if (rc) {
2865 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
2866 } else { /* decode response */
2867/* BB Add logic to parse referrals here */
2868 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2869
2870 if (rc || (pSMBr->ByteCount < 17)) /* BB also check enough total bytes returned */
2871 rc = -EIO; /* bad smb */
2872 else {
2873 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2874 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2875
2876 cFYI(1,
2877 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
2878 pSMBr->ByteCount, data_offset));
2879 referrals =
2880 (struct dfs_referral_level_3 *)
2881 (8 /* sizeof start of data block */ +
2882 data_offset +
2883 (char *) &pSMBr->hdr.Protocol);
2884 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",
2885 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)));
2886 /* BB This field is actually two bytes in from start of
2887 data block so we could do safety check that DataBlock
2888 begins at address of pSMBr->NumberOfReferrals */
2889 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
2890
2891 /* BB Fix below so can return more than one referral */
2892 if(*number_of_UNC_in_array > 1)
2893 *number_of_UNC_in_array = 1;
2894
2895 /* get the length of the strings describing refs */
2896 name_len = 0;
2897 for(i=0;i<*number_of_UNC_in_array;i++) {
2898 /* make sure that DfsPathOffset not past end */
2899 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
2900 if (offset > data_count) {
2901 /* if invalid referral, stop here and do
2902 not try to copy any more */
2903 *number_of_UNC_in_array = i;
2904 break;
2905 }
2906 temp = ((char *)referrals) + offset;
2907
2908 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2909 name_len += UniStrnlen((wchar_t *)temp,data_count);
2910 } else {
2911 name_len += strnlen(temp,data_count);
2912 }
2913 referrals++;
2914 /* BB add check that referral pointer does not fall off end PDU */
2915
2916 }
2917 /* BB add check for name_len bigger than bcc */
2918 *targetUNCs =
2919 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
2920 if(*targetUNCs == NULL) {
2921 rc = -ENOMEM;
2922 goto GetDFSRefExit;
2923 }
2924 /* copy the ref strings */
2925 referrals =
2926 (struct dfs_referral_level_3 *)
2927 (8 /* sizeof data hdr */ +
2928 data_offset +
2929 (char *) &pSMBr->hdr.Protocol);
2930
2931 for(i=0;i<*number_of_UNC_in_array;i++) {
2932 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
2933 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2934 cifs_strfromUCS_le(*targetUNCs,
2935 (wchar_t *) temp, name_len, nls_codepage);
2936 } else {
2937 strncpy(*targetUNCs,temp,name_len);
2938 }
2939 /* BB update target_uncs pointers */
2940 referrals++;
2941 }
2942 temp = *targetUNCs;
2943 temp[name_len] = 0;
2944 }
2945
2946 }
2947GetDFSRefExit:
2948 if (pSMB)
2949 cifs_buf_release(pSMB);
2950
2951 if (rc == -EAGAIN)
2952 goto getDFSRetry;
2953
2954 return rc;
2955}
2956
2957int
2958CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
2959 struct kstatfs *FSData, const struct nls_table *nls_codepage)
2960{
2961/* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
2962 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2963 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2964 FILE_SYSTEM_INFO *response_data;
2965 int rc = 0;
2966 int bytes_returned = 0;
2967 __u16 params, byte_count;
2968
2969 cFYI(1, ("In QFSInfo"));
2970QFSInfoRetry:
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_SIZE_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 QFSInfo = %d", rc));
3003 } else { /* decode response */
3004 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3005
3006 if (rc || (pSMBr->ByteCount < 24)) /* BB alsO CHEck enough total bytes returned */
3007 rc = -EIO; /* bad smb */
3008 else {
3009 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3010 cFYI(1,
3011 ("Decoding qfsinfo response. BCC: %d Offset %d",
3012 pSMBr->ByteCount, data_offset));
3013
3014 response_data =
3015 (FILE_SYSTEM_INFO
3016 *) (((char *) &pSMBr->hdr.Protocol) +
3017 data_offset);
3018 FSData->f_bsize =
3019 le32_to_cpu(response_data->BytesPerSector) *
3020 le32_to_cpu(response_data->
3021 SectorsPerAllocationUnit);
3022 FSData->f_blocks =
3023 le64_to_cpu(response_data->TotalAllocationUnits);
3024 FSData->f_bfree = FSData->f_bavail =
3025 le64_to_cpu(response_data->FreeAllocationUnits);
3026 cFYI(1,
3027 ("Blocks: %lld Free: %lld Block size %ld",
3028 (unsigned long long)FSData->f_blocks,
3029 (unsigned long long)FSData->f_bfree,
3030 FSData->f_bsize));
3031 }
3032 }
3033 cifs_buf_release(pSMB);
3034
3035 if (rc == -EAGAIN)
3036 goto QFSInfoRetry;
3037
3038 return rc;
3039}
3040
3041int
3042CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon,
3043 const struct nls_table *nls_codepage)
3044{
3045/* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
3046 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3047 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3048 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
3049 int rc = 0;
3050 int bytes_returned = 0;
3051 __u16 params, byte_count;
3052
3053 cFYI(1, ("In QFSAttributeInfo"));
3054QFSAttributeRetry:
3055 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3056 (void **) &pSMBr);
3057 if (rc)
3058 return rc;
3059
3060 params = 2; /* level */
3061 pSMB->TotalDataCount = 0;
3062 pSMB->MaxParameterCount = cpu_to_le16(2);
3063 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3064 pSMB->MaxSetupCount = 0;
3065 pSMB->Reserved = 0;
3066 pSMB->Flags = 0;
3067 pSMB->Timeout = 0;
3068 pSMB->Reserved2 = 0;
3069 byte_count = params + 1 /* pad */ ;
3070 pSMB->TotalParameterCount = cpu_to_le16(params);
3071 pSMB->ParameterCount = pSMB->TotalParameterCount;
3072 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3073 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3074 pSMB->DataCount = 0;
3075 pSMB->DataOffset = 0;
3076 pSMB->SetupCount = 1;
3077 pSMB->Reserved3 = 0;
3078 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3079 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
3080 pSMB->hdr.smb_buf_length += byte_count;
3081 pSMB->ByteCount = cpu_to_le16(byte_count);
3082
3083 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3084 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3085 if (rc) {
3086 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
3087 } else { /* decode response */
3088 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3089
3090 if (rc || (pSMBr->ByteCount < 13)) { /* BB also check enough bytes returned */
3091 rc = -EIO; /* bad smb */
3092 } else {
3093 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3094 response_data =
3095 (FILE_SYSTEM_ATTRIBUTE_INFO
3096 *) (((char *) &pSMBr->hdr.Protocol) +
3097 data_offset);
3098 memcpy(&tcon->fsAttrInfo, response_data,
3099 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
3100 }
3101 }
3102 cifs_buf_release(pSMB);
3103
3104 if (rc == -EAGAIN)
3105 goto QFSAttributeRetry;
3106
3107 return rc;
3108}
3109
3110int
3111CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon,
3112 const struct nls_table *nls_codepage)
3113{
3114/* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
3115 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3116 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3117 FILE_SYSTEM_DEVICE_INFO *response_data;
3118 int rc = 0;
3119 int bytes_returned = 0;
3120 __u16 params, byte_count;
3121
3122 cFYI(1, ("In QFSDeviceInfo"));
3123QFSDeviceRetry:
3124 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3125 (void **) &pSMBr);
3126 if (rc)
3127 return rc;
3128
3129 params = 2; /* level */
3130 pSMB->TotalDataCount = 0;
3131 pSMB->MaxParameterCount = cpu_to_le16(2);
3132 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3133 pSMB->MaxSetupCount = 0;
3134 pSMB->Reserved = 0;
3135 pSMB->Flags = 0;
3136 pSMB->Timeout = 0;
3137 pSMB->Reserved2 = 0;
3138 byte_count = params + 1 /* pad */ ;
3139 pSMB->TotalParameterCount = cpu_to_le16(params);
3140 pSMB->ParameterCount = pSMB->TotalParameterCount;
3141 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3142 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3143
3144 pSMB->DataCount = 0;
3145 pSMB->DataOffset = 0;
3146 pSMB->SetupCount = 1;
3147 pSMB->Reserved3 = 0;
3148 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3149 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
3150 pSMB->hdr.smb_buf_length += byte_count;
3151 pSMB->ByteCount = cpu_to_le16(byte_count);
3152
3153 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3154 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3155 if (rc) {
3156 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
3157 } else { /* decode response */
3158 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3159
3160 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
3161 rc = -EIO; /* bad smb */
3162 else {
3163 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3164 response_data =
3165 (FILE_SYSTEM_DEVICE_INFO
3166 *) (((char *) &pSMBr->hdr.Protocol) +
3167 data_offset);
3168 memcpy(&tcon->fsDevInfo, response_data,
3169 sizeof (FILE_SYSTEM_DEVICE_INFO));
3170 }
3171 }
3172 cifs_buf_release(pSMB);
3173
3174 if (rc == -EAGAIN)
3175 goto QFSDeviceRetry;
3176
3177 return rc;
3178}
3179
3180int
3181CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon,
3182 const struct nls_table *nls_codepage)
3183{
3184/* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
3185 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3186 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3187 FILE_SYSTEM_UNIX_INFO *response_data;
3188 int rc = 0;
3189 int bytes_returned = 0;
3190 __u16 params, byte_count;
3191
3192 cFYI(1, ("In QFSUnixInfo"));
3193QFSUnixRetry:
3194 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3195 (void **) &pSMBr);
3196 if (rc)
3197 return rc;
3198
3199 params = 2; /* level */
3200 pSMB->TotalDataCount = 0;
3201 pSMB->DataCount = 0;
3202 pSMB->DataOffset = 0;
3203 pSMB->MaxParameterCount = cpu_to_le16(2);
3204 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3205 pSMB->MaxSetupCount = 0;
3206 pSMB->Reserved = 0;
3207 pSMB->Flags = 0;
3208 pSMB->Timeout = 0;
3209 pSMB->Reserved2 = 0;
3210 byte_count = params + 1 /* pad */ ;
3211 pSMB->ParameterCount = cpu_to_le16(params);
3212 pSMB->TotalParameterCount = pSMB->ParameterCount;
3213 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3214 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3215 pSMB->SetupCount = 1;
3216 pSMB->Reserved3 = 0;
3217 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3218 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
3219 pSMB->hdr.smb_buf_length += byte_count;
3220 pSMB->ByteCount = cpu_to_le16(byte_count);
3221
3222 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3223 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3224 if (rc) {
3225 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
3226 } else { /* decode response */
3227 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3228
3229 if (rc || (pSMBr->ByteCount < 13)) {
3230 rc = -EIO; /* bad smb */
3231 } else {
3232 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3233 response_data =
3234 (FILE_SYSTEM_UNIX_INFO
3235 *) (((char *) &pSMBr->hdr.Protocol) +
3236 data_offset);
3237 memcpy(&tcon->fsUnixInfo, response_data,
3238 sizeof (FILE_SYSTEM_UNIX_INFO));
3239 }
3240 }
3241 cifs_buf_release(pSMB);
3242
3243 if (rc == -EAGAIN)
3244 goto QFSUnixRetry;
3245
3246
3247 return rc;
3248}
3249
3250
3251int
3252CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
3253 struct kstatfs *FSData, const struct nls_table *nls_codepage)
3254{
3255/* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
3256 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3257 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3258 FILE_SYSTEM_POSIX_INFO *response_data;
3259 int rc = 0;
3260 int bytes_returned = 0;
3261 __u16 params, byte_count;
3262
3263 cFYI(1, ("In QFSPosixInfo"));
3264QFSPosixRetry:
3265 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3266 (void **) &pSMBr);
3267 if (rc)
3268 return rc;
3269
3270 params = 2; /* level */
3271 pSMB->TotalDataCount = 0;
3272 pSMB->DataCount = 0;
3273 pSMB->DataOffset = 0;
3274 pSMB->MaxParameterCount = cpu_to_le16(2);
3275 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3276 pSMB->MaxSetupCount = 0;
3277 pSMB->Reserved = 0;
3278 pSMB->Flags = 0;
3279 pSMB->Timeout = 0;
3280 pSMB->Reserved2 = 0;
3281 byte_count = params + 1 /* pad */ ;
3282 pSMB->ParameterCount = cpu_to_le16(params);
3283 pSMB->TotalParameterCount = pSMB->ParameterCount;
3284 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3285 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3286 pSMB->SetupCount = 1;
3287 pSMB->Reserved3 = 0;
3288 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3289 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
3290 pSMB->hdr.smb_buf_length += byte_count;
3291 pSMB->ByteCount = cpu_to_le16(byte_count);
3292
3293 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3294 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3295 if (rc) {
3296 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
3297 } else { /* decode response */
3298 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3299
3300 if (rc || (pSMBr->ByteCount < 13)) {
3301 rc = -EIO; /* bad smb */
3302 } else {
3303 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3304 response_data =
3305 (FILE_SYSTEM_POSIX_INFO
3306 *) (((char *) &pSMBr->hdr.Protocol) +
3307 data_offset);
3308 FSData->f_bsize =
3309 le32_to_cpu(response_data->BlockSize);
3310 FSData->f_blocks =
3311 le64_to_cpu(response_data->TotalBlocks);
3312 FSData->f_bfree =
3313 le64_to_cpu(response_data->BlocksAvail);
3314 if(response_data->UserBlocksAvail == -1) {
3315 FSData->f_bavail = FSData->f_bfree;
3316 } else {
3317 FSData->f_bavail =
3318 le64_to_cpu(response_data->UserBlocksAvail);
3319 }
3320 if(response_data->TotalFileNodes != -1)
3321 FSData->f_files =
3322 le64_to_cpu(response_data->TotalFileNodes);
3323 if(response_data->FreeFileNodes != -1)
3324 FSData->f_ffree =
3325 le64_to_cpu(response_data->FreeFileNodes);
3326 }
3327 }
3328 cifs_buf_release(pSMB);
3329
3330 if (rc == -EAGAIN)
3331 goto QFSPosixRetry;
3332
3333 return rc;
3334}
3335
3336
3337/* We can not use write of zero bytes trick to
3338 set file size due to need for large file support. Also note that
3339 this SetPathInfo is preferred to SetFileInfo based method in next
3340 routine which is only needed to work around a sharing violation bug
3341 in Samba which this routine can run into */
3342
3343int
3344CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3345 __u64 size, int SetAllocation, const struct nls_table *nls_codepage)
3346{
3347 struct smb_com_transaction2_spi_req *pSMB = NULL;
3348 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3349 struct file_end_of_file_info *parm_data;
3350 int name_len;
3351 int rc = 0;
3352 int bytes_returned = 0;
3353 __u16 params, byte_count, data_count, param_offset, offset;
3354
3355 cFYI(1, ("In SetEOF"));
3356SetEOFRetry:
3357 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3358 (void **) &pSMBr);
3359 if (rc)
3360 return rc;
3361
3362 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3363 name_len =
3364 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3365 /* find define for this maxpathcomponent */
3366 , nls_codepage);
3367 name_len++; /* trailing null */
3368 name_len *= 2;
3369 } else { /* BB improve the check for buffer overruns BB */
3370 name_len = strnlen(fileName, PATH_MAX);
3371 name_len++; /* trailing null */
3372 strncpy(pSMB->FileName, fileName, name_len);
3373 }
3374 params = 6 + name_len;
3375 data_count = sizeof (struct file_end_of_file_info);
3376 pSMB->MaxParameterCount = cpu_to_le16(2);
3377 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
3378 pSMB->MaxSetupCount = 0;
3379 pSMB->Reserved = 0;
3380 pSMB->Flags = 0;
3381 pSMB->Timeout = 0;
3382 pSMB->Reserved2 = 0;
3383 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3384 InformationLevel) - 4;
3385 offset = param_offset + params;
3386 if(SetAllocation) {
3387 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3388 pSMB->InformationLevel =
3389 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3390 else
3391 pSMB->InformationLevel =
3392 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3393 } else /* Set File Size */ {
3394 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3395 pSMB->InformationLevel =
3396 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3397 else
3398 pSMB->InformationLevel =
3399 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3400 }
3401
3402 parm_data =
3403 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3404 offset);
3405 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3406 pSMB->DataOffset = cpu_to_le16(offset);
3407 pSMB->SetupCount = 1;
3408 pSMB->Reserved3 = 0;
3409 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3410 byte_count = 3 /* pad */ + params + data_count;
3411 pSMB->DataCount = cpu_to_le16(data_count);
3412 pSMB->TotalDataCount = pSMB->DataCount;
3413 pSMB->ParameterCount = cpu_to_le16(params);
3414 pSMB->TotalParameterCount = pSMB->ParameterCount;
3415 pSMB->Reserved4 = 0;
3416 pSMB->hdr.smb_buf_length += byte_count;
3417 parm_data->FileSize = cpu_to_le64(size);
3418 pSMB->ByteCount = cpu_to_le16(byte_count);
3419 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3420 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3421 if (rc) {
3422 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
3423 }
3424
3425 cifs_buf_release(pSMB);
3426
3427 if (rc == -EAGAIN)
3428 goto SetEOFRetry;
3429
3430 return rc;
3431}
3432
3433int
3434CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
3435 __u16 fid, __u32 pid_of_opener, int SetAllocation)
3436{
3437 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3438 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3439 char *data_offset;
3440 struct file_end_of_file_info *parm_data;
3441 int rc = 0;
3442 int bytes_returned = 0;
3443 __u16 params, param_offset, offset, byte_count, count;
3444
3445 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
3446 (long long)size));
3447 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3448 (void **) &pSMBr);
3449 if (rc)
3450 return rc;
3451
3452 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3453 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
3454
3455 params = 6;
3456 pSMB->MaxSetupCount = 0;
3457 pSMB->Reserved = 0;
3458 pSMB->Flags = 0;
3459 pSMB->Timeout = 0;
3460 pSMB->Reserved2 = 0;
3461 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3462 offset = param_offset + params;
3463
3464 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3465
3466 count = sizeof(struct file_end_of_file_info);
3467 pSMB->MaxParameterCount = cpu_to_le16(2);
3468 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3469 pSMB->SetupCount = 1;
3470 pSMB->Reserved3 = 0;
3471 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3472 byte_count = 3 /* pad */ + params + count;
3473 pSMB->DataCount = cpu_to_le16(count);
3474 pSMB->ParameterCount = cpu_to_le16(params);
3475 pSMB->TotalDataCount = pSMB->DataCount;
3476 pSMB->TotalParameterCount = pSMB->ParameterCount;
3477 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3478 parm_data =
3479 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3480 offset);
3481 pSMB->DataOffset = cpu_to_le16(offset);
3482 parm_data->FileSize = cpu_to_le64(size);
3483 pSMB->Fid = fid;
3484 if(SetAllocation) {
3485 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3486 pSMB->InformationLevel =
3487 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3488 else
3489 pSMB->InformationLevel =
3490 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3491 } else /* Set File Size */ {
3492 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3493 pSMB->InformationLevel =
3494 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3495 else
3496 pSMB->InformationLevel =
3497 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3498 }
3499 pSMB->Reserved4 = 0;
3500 pSMB->hdr.smb_buf_length += byte_count;
3501 pSMB->ByteCount = cpu_to_le16(byte_count);
3502 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3503 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3504 if (rc) {
3505 cFYI(1,
3506 ("Send error in SetFileInfo (SetFileSize) = %d",
3507 rc));
3508 }
3509
3510 if (pSMB)
3511 cifs_buf_release(pSMB);
3512
3513 /* Note: On -EAGAIN error only caller can retry on handle based calls
3514 since file handle passed in no longer valid */
3515
3516 return rc;
3517}
3518
3519/* Some legacy servers such as NT4 require that the file times be set on
3520 an open handle, rather than by pathname - this is awkward due to
3521 potential access conflicts on the open, but it is unavoidable for these
3522 old servers since the only other choice is to go from 100 nanosecond DCE
3523 time and resort to the original setpathinfo level which takes the ancient
3524 DOS time format with 2 second granularity */
3525int
3526CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data,
3527 __u16 fid)
3528{
3529 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3530 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3531 char *data_offset;
3532 int rc = 0;
3533 int bytes_returned = 0;
3534 __u16 params, param_offset, offset, byte_count, count;
3535
3536 cFYI(1, ("Set Times (via SetFileInfo)"));
3537 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3538 (void **) &pSMBr);
3539 if (rc)
3540 return rc;
3541
3542 /* At this point there is no need to override the current pid
3543 with the pid of the opener, but that could change if we someday
3544 use an existing handle (rather than opening one on the fly) */
3545 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3546 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
3547
3548 params = 6;
3549 pSMB->MaxSetupCount = 0;
3550 pSMB->Reserved = 0;
3551 pSMB->Flags = 0;
3552 pSMB->Timeout = 0;
3553 pSMB->Reserved2 = 0;
3554 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3555 offset = param_offset + params;
3556
3557 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3558
3559 count = sizeof (FILE_BASIC_INFO);
3560 pSMB->MaxParameterCount = cpu_to_le16(2);
3561 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3562 pSMB->SetupCount = 1;
3563 pSMB->Reserved3 = 0;
3564 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3565 byte_count = 3 /* pad */ + params + count;
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 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3571 pSMB->DataOffset = cpu_to_le16(offset);
3572 pSMB->Fid = fid;
3573 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3574 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3575 else
3576 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3577 pSMB->Reserved4 = 0;
3578 pSMB->hdr.smb_buf_length += byte_count;
3579 pSMB->ByteCount = cpu_to_le16(byte_count);
3580 memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
3581 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3582 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3583 if (rc) {
3584 cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
3585 }
3586
3587 cifs_buf_release(pSMB);
3588
3589 /* Note: On -EAGAIN error only caller can retry on handle based calls
3590 since file handle passed in no longer valid */
3591
3592 return rc;
3593}
3594
3595
3596int
3597CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3598 const FILE_BASIC_INFO * data,
3599 const struct nls_table *nls_codepage)
3600{
3601 TRANSACTION2_SPI_REQ *pSMB = NULL;
3602 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3603 int name_len;
3604 int rc = 0;
3605 int bytes_returned = 0;
3606 char *data_offset;
3607 __u16 params, param_offset, offset, byte_count, count;
3608
3609 cFYI(1, ("In SetTimes"));
3610
3611SetTimesRetry:
3612 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3613 (void **) &pSMBr);
3614 if (rc)
3615 return rc;
3616
3617 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3618 name_len =
3619 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3620 /* find define for this maxpathcomponent */
3621 , nls_codepage);
3622 name_len++; /* trailing null */
3623 name_len *= 2;
3624 } else { /* BB improve the check for buffer overruns BB */
3625 name_len = strnlen(fileName, PATH_MAX);
3626 name_len++; /* trailing null */
3627 strncpy(pSMB->FileName, fileName, name_len);
3628 }
3629
3630 params = 6 + name_len;
3631 count = sizeof (FILE_BASIC_INFO);
3632 pSMB->MaxParameterCount = cpu_to_le16(2);
3633 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3634 pSMB->MaxSetupCount = 0;
3635 pSMB->Reserved = 0;
3636 pSMB->Flags = 0;
3637 pSMB->Timeout = 0;
3638 pSMB->Reserved2 = 0;
3639 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3640 InformationLevel) - 4;
3641 offset = param_offset + params;
3642 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3643 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3644 pSMB->DataOffset = cpu_to_le16(offset);
3645 pSMB->SetupCount = 1;
3646 pSMB->Reserved3 = 0;
3647 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3648 byte_count = 3 /* pad */ + params + count;
3649
3650 pSMB->DataCount = cpu_to_le16(count);
3651 pSMB->ParameterCount = cpu_to_le16(params);
3652 pSMB->TotalDataCount = pSMB->DataCount;
3653 pSMB->TotalParameterCount = pSMB->ParameterCount;
3654 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3655 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3656 else
3657 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3658 pSMB->Reserved4 = 0;
3659 pSMB->hdr.smb_buf_length += byte_count;
3660 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
3661 pSMB->ByteCount = cpu_to_le16(byte_count);
3662 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3663 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3664 if (rc) {
3665 cFYI(1, ("SetPathInfo (times) returned %d", rc));
3666 }
3667
3668 cifs_buf_release(pSMB);
3669
3670 if (rc == -EAGAIN)
3671 goto SetTimesRetry;
3672
3673 return rc;
3674}
3675
3676/* Can not be used to set time stamps yet (due to old DOS time format) */
3677/* Can be used to set attributes */
3678#if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
3679 handling it anyway and NT4 was what we thought it would be needed for
3680 Do not delete it until we prove whether needed for Win9x though */
3681int
3682CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
3683 __u16 dos_attrs, const struct nls_table *nls_codepage)
3684{
3685 SETATTR_REQ *pSMB = NULL;
3686 SETATTR_RSP *pSMBr = NULL;
3687 int rc = 0;
3688 int bytes_returned;
3689 int name_len;
3690
3691 cFYI(1, ("In SetAttrLegacy"));
3692
3693SetAttrLgcyRetry:
3694 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
3695 (void **) &pSMBr);
3696 if (rc)
3697 return rc;
3698
3699 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3700 name_len =
3701 cifs_strtoUCS((wchar_t *) pSMB->fileName, fileName,
3702 PATH_MAX, nls_codepage);
3703 name_len++; /* trailing null */
3704 name_len *= 2;
3705 } else { /* BB improve the check for buffer overruns BB */
3706 name_len = strnlen(fileName, PATH_MAX);
3707 name_len++; /* trailing null */
3708 strncpy(pSMB->fileName, fileName, name_len);
3709 }
3710 pSMB->attr = cpu_to_le16(dos_attrs);
3711 pSMB->BufferFormat = 0x04;
3712 pSMB->hdr.smb_buf_length += name_len + 1;
3713 pSMB->ByteCount = cpu_to_le16(name_len + 1);
3714 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3715 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3716 if (rc) {
3717 cFYI(1, ("Error in LegacySetAttr = %d", rc));
3718 }
3719
3720 cifs_buf_release(pSMB);
3721
3722 if (rc == -EAGAIN)
3723 goto SetAttrLgcyRetry;
3724
3725 return rc;
3726}
3727#endif /* temporarily unneeded SetAttr legacy function */
3728
3729int
3730CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
3731 char *fileName, __u64 mode, __u64 uid, __u64 gid,
3732 dev_t device, const struct nls_table *nls_codepage)
3733{
3734 TRANSACTION2_SPI_REQ *pSMB = NULL;
3735 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3736 int name_len;
3737 int rc = 0;
3738 int bytes_returned = 0;
3739 FILE_UNIX_BASIC_INFO *data_offset;
3740 __u16 params, param_offset, offset, count, byte_count;
3741
3742 cFYI(1, ("In SetUID/GID/Mode"));
3743setPermsRetry:
3744 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3745 (void **) &pSMBr);
3746 if (rc)
3747 return rc;
3748
3749 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3750 name_len =
3751 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
3752 /* find define for this maxpathcomponent */
3753 , nls_codepage);
3754 name_len++; /* trailing null */
3755 name_len *= 2;
3756 } else { /* BB improve the check for buffer overruns BB */
3757 name_len = strnlen(fileName, PATH_MAX);
3758 name_len++; /* trailing null */
3759 strncpy(pSMB->FileName, fileName, name_len);
3760 }
3761
3762 params = 6 + name_len;
3763 count = sizeof (FILE_UNIX_BASIC_INFO);
3764 pSMB->MaxParameterCount = cpu_to_le16(2);
3765 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3766 pSMB->MaxSetupCount = 0;
3767 pSMB->Reserved = 0;
3768 pSMB->Flags = 0;
3769 pSMB->Timeout = 0;
3770 pSMB->Reserved2 = 0;
3771 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3772 InformationLevel) - 4;
3773 offset = param_offset + params;
3774 data_offset =
3775 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
3776 offset);
3777 memset(data_offset, 0, count);
3778 pSMB->DataOffset = cpu_to_le16(offset);
3779 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3780 pSMB->SetupCount = 1;
3781 pSMB->Reserved3 = 0;
3782 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3783 byte_count = 3 /* pad */ + params + count;
3784 pSMB->ParameterCount = cpu_to_le16(params);
3785 pSMB->DataCount = cpu_to_le16(count);
3786 pSMB->TotalParameterCount = pSMB->ParameterCount;
3787 pSMB->TotalDataCount = pSMB->DataCount;
3788 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
3789 pSMB->Reserved4 = 0;
3790 pSMB->hdr.smb_buf_length += byte_count;
3791 data_offset->Uid = cpu_to_le64(uid);
3792 data_offset->Gid = cpu_to_le64(gid);
3793 /* better to leave device as zero when it is */
3794 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
3795 data_offset->DevMinor = cpu_to_le64(MINOR(device));
3796 data_offset->Permissions = cpu_to_le64(mode);
3797
3798 if(S_ISREG(mode))
3799 data_offset->Type = cpu_to_le32(UNIX_FILE);
3800 else if(S_ISDIR(mode))
3801 data_offset->Type = cpu_to_le32(UNIX_DIR);
3802 else if(S_ISLNK(mode))
3803 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
3804 else if(S_ISCHR(mode))
3805 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
3806 else if(S_ISBLK(mode))
3807 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
3808 else if(S_ISFIFO(mode))
3809 data_offset->Type = cpu_to_le32(UNIX_FIFO);
3810 else if(S_ISSOCK(mode))
3811 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
3812
3813
3814 pSMB->ByteCount = cpu_to_le16(byte_count);
3815 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3816 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3817 if (rc) {
3818 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
3819 }
3820
3821 if (pSMB)
3822 cifs_buf_release(pSMB);
3823 if (rc == -EAGAIN)
3824 goto setPermsRetry;
3825 return rc;
3826}
3827
3828int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
3829 const int notify_subdirs, const __u16 netfid,
3830 __u32 filter, const struct nls_table *nls_codepage)
3831{
3832 int rc = 0;
3833 struct smb_com_transaction_change_notify_req * pSMB = NULL;
3834 struct smb_com_transaction_change_notify_rsp * pSMBr = NULL;
3835 int bytes_returned;
3836
3837 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
3838 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3839 (void **) &pSMBr);
3840 if (rc)
3841 return rc;
3842
3843 pSMB->TotalParameterCount = 0 ;
3844 pSMB->TotalDataCount = 0;
3845 pSMB->MaxParameterCount = cpu_to_le32(2);
3846 /* BB find exact data count max from sess structure BB */
3847 pSMB->MaxDataCount = 0; /* same in little endian or be */
3848 pSMB->MaxSetupCount = 4;
3849 pSMB->Reserved = 0;
3850 pSMB->ParameterOffset = 0;
3851 pSMB->DataCount = 0;
3852 pSMB->DataOffset = 0;
3853 pSMB->SetupCount = 4; /* single byte does not need le conversion */
3854 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
3855 pSMB->ParameterCount = pSMB->TotalParameterCount;
3856 if(notify_subdirs)
3857 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
3858 pSMB->Reserved2 = 0;
3859 pSMB->CompletionFilter = cpu_to_le32(filter);
3860 pSMB->Fid = netfid; /* file handle always le */
3861 pSMB->ByteCount = 0;
3862
3863 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3864 (struct smb_hdr *) pSMBr, &bytes_returned, -1);
3865 if (rc) {
3866 cFYI(1, ("Error in Notify = %d", rc));
3867 }
3868 cifs_buf_release(pSMB);
3869 return rc;
3870}
3871#ifdef CONFIG_CIFS_XATTR
3872ssize_t
3873CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
3874 const unsigned char *searchName,
3875 char * EAData, size_t buf_size,
3876 const struct nls_table *nls_codepage)
3877{
3878 /* BB assumes one setup word */
3879 TRANSACTION2_QPI_REQ *pSMB = NULL;
3880 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3881 int rc = 0;
3882 int bytes_returned;
3883 int name_len;
3884 struct fea * temp_fea;
3885 char * temp_ptr;
3886 __u16 params, byte_count;
3887
3888 cFYI(1, ("In Query All EAs path %s", searchName));
3889QAllEAsRetry:
3890 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3891 (void **) &pSMBr);
3892 if (rc)
3893 return rc;
3894
3895 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3896 name_len =
3897 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
3898 /* find define for this maxpathcomponent */
3899 , nls_codepage);
3900 name_len++; /* trailing null */
3901 name_len *= 2;
3902 } else { /* BB improve the check for buffer overruns BB */
3903 name_len = strnlen(searchName, PATH_MAX);
3904 name_len++; /* trailing null */
3905 strncpy(pSMB->FileName, searchName, name_len);
3906 }
3907
3908 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3909 pSMB->TotalDataCount = 0;
3910 pSMB->MaxParameterCount = cpu_to_le16(2);
3911 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3912 pSMB->MaxSetupCount = 0;
3913 pSMB->Reserved = 0;
3914 pSMB->Flags = 0;
3915 pSMB->Timeout = 0;
3916 pSMB->Reserved2 = 0;
3917 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3918 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3919 pSMB->DataCount = 0;
3920 pSMB->DataOffset = 0;
3921 pSMB->SetupCount = 1;
3922 pSMB->Reserved3 = 0;
3923 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3924 byte_count = params + 1 /* pad */ ;
3925 pSMB->TotalParameterCount = cpu_to_le16(params);
3926 pSMB->ParameterCount = pSMB->TotalParameterCount;
3927 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3928 pSMB->Reserved4 = 0;
3929 pSMB->hdr.smb_buf_length += byte_count;
3930 pSMB->ByteCount = cpu_to_le16(byte_count);
3931
3932 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3933 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3934 if (rc) {
3935 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
3936 } else { /* decode response */
3937 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3938
3939 /* BB also check enough total bytes returned */
3940 /* BB we need to improve the validity checking
3941 of these trans2 responses */
3942 if (rc || (pSMBr->ByteCount < 4))
3943 rc = -EIO; /* bad smb */
3944 /* else if (pFindData){
3945 memcpy((char *) pFindData,
3946 (char *) &pSMBr->hdr.Protocol +
3947 data_offset, kl);
3948 }*/ else {
3949 /* check that length of list is not more than bcc */
3950 /* check that each entry does not go beyond length
3951 of list */
3952 /* check that each element of each entry does not
3953 go beyond end of list */
3954 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3955 struct fealist * ea_response_data;
3956 rc = 0;
3957 /* validate_trans2_offsets() */
3958 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
3959 ea_response_data = (struct fealist *)
3960 (((char *) &pSMBr->hdr.Protocol) +
3961 data_offset);
3962 name_len = le32_to_cpu(ea_response_data->list_len);
3963 cFYI(1,("ea length %d", name_len));
3964 if(name_len <= 8) {
3965 /* returned EA size zeroed at top of function */
3966 cFYI(1,("empty EA list returned from server"));
3967 } else {
3968 /* account for ea list len */
3969 name_len -= 4;
3970 temp_fea = ea_response_data->list;
3971 temp_ptr = (char *)temp_fea;
3972 while(name_len > 0) {
3973 __u16 value_len;
3974 name_len -= 4;
3975 temp_ptr += 4;
3976 rc += temp_fea->name_len;
3977 /* account for prefix user. and trailing null */
3978 rc = rc + 5 + 1;
3979 if(rc<(int)buf_size) {
3980 memcpy(EAData,"user.",5);
3981 EAData+=5;
3982 memcpy(EAData,temp_ptr,temp_fea->name_len);
3983 EAData+=temp_fea->name_len;
3984 /* null terminate name */
3985 *EAData = 0;
3986 EAData = EAData + 1;
3987 } else if(buf_size == 0) {
3988 /* skip copy - calc size only */
3989 } else {
3990 /* stop before overrun buffer */
3991 rc = -ERANGE;
3992 break;
3993 }
3994 name_len -= temp_fea->name_len;
3995 temp_ptr += temp_fea->name_len;
3996 /* account for trailing null */
3997 name_len--;
3998 temp_ptr++;
3999 value_len = le16_to_cpu(temp_fea->value_len);
4000 name_len -= value_len;
4001 temp_ptr += value_len;
4002 /* BB check that temp_ptr is still within smb BB*/
4003 /* no trailing null to account for in value len */
4004 /* go on to next EA */
4005 temp_fea = (struct fea *)temp_ptr;
4006 }
4007 }
4008 }
4009 }
4010 if (pSMB)
4011 cifs_buf_release(pSMB);
4012 if (rc == -EAGAIN)
4013 goto QAllEAsRetry;
4014
4015 return (ssize_t)rc;
4016}
4017
4018ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
4019 const unsigned char * searchName,const unsigned char * ea_name,
4020 unsigned char * ea_value, size_t buf_size,
4021 const struct nls_table *nls_codepage)
4022{
4023 TRANSACTION2_QPI_REQ *pSMB = NULL;
4024 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4025 int rc = 0;
4026 int bytes_returned;
4027 int name_len;
4028 struct fea * temp_fea;
4029 char * temp_ptr;
4030 __u16 params, byte_count;
4031
4032 cFYI(1, ("In Query EA path %s", searchName));
4033QEARetry:
4034 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4035 (void **) &pSMBr);
4036 if (rc)
4037 return rc;
4038
4039 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4040 name_len =
4041 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
4042 /* find define for this maxpathcomponent */
4043 , nls_codepage);
4044 name_len++; /* trailing null */
4045 name_len *= 2;
4046 } else { /* BB improve the check for buffer overruns BB */
4047 name_len = strnlen(searchName, PATH_MAX);
4048 name_len++; /* trailing null */
4049 strncpy(pSMB->FileName, searchName, name_len);
4050 }
4051
4052 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4053 pSMB->TotalDataCount = 0;
4054 pSMB->MaxParameterCount = cpu_to_le16(2);
4055 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4056 pSMB->MaxSetupCount = 0;
4057 pSMB->Reserved = 0;
4058 pSMB->Flags = 0;
4059 pSMB->Timeout = 0;
4060 pSMB->Reserved2 = 0;
4061 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4062 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
4063 pSMB->DataCount = 0;
4064 pSMB->DataOffset = 0;
4065 pSMB->SetupCount = 1;
4066 pSMB->Reserved3 = 0;
4067 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4068 byte_count = params + 1 /* pad */ ;
4069 pSMB->TotalParameterCount = cpu_to_le16(params);
4070 pSMB->ParameterCount = pSMB->TotalParameterCount;
4071 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
4072 pSMB->Reserved4 = 0;
4073 pSMB->hdr.smb_buf_length += byte_count;
4074 pSMB->ByteCount = cpu_to_le16(byte_count);
4075
4076 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4077 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4078 if (rc) {
4079 cFYI(1, ("Send error in Query EA = %d", rc));
4080 } else { /* decode response */
4081 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4082
4083 /* BB also check enough total bytes returned */
4084 /* BB we need to improve the validity checking
4085 of these trans2 responses */
4086 if (rc || (pSMBr->ByteCount < 4))
4087 rc = -EIO; /* bad smb */
4088 /* else if (pFindData){
4089 memcpy((char *) pFindData,
4090 (char *) &pSMBr->hdr.Protocol +
4091 data_offset, kl);
4092 }*/ else {
4093 /* check that length of list is not more than bcc */
4094 /* check that each entry does not go beyond length
4095 of list */
4096 /* check that each element of each entry does not
4097 go beyond end of list */
4098 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4099 struct fealist * ea_response_data;
4100 rc = -ENODATA;
4101 /* validate_trans2_offsets() */
4102 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4103 ea_response_data = (struct fealist *)
4104 (((char *) &pSMBr->hdr.Protocol) +
4105 data_offset);
4106 name_len = le32_to_cpu(ea_response_data->list_len);
4107 cFYI(1,("ea length %d", name_len));
4108 if(name_len <= 8) {
4109 /* returned EA size zeroed at top of function */
4110 cFYI(1,("empty EA list returned from server"));
4111 } else {
4112 /* account for ea list len */
4113 name_len -= 4;
4114 temp_fea = ea_response_data->list;
4115 temp_ptr = (char *)temp_fea;
4116 /* loop through checking if we have a matching
4117 name and then return the associated value */
4118 while(name_len > 0) {
4119 __u16 value_len;
4120 name_len -= 4;
4121 temp_ptr += 4;
4122 value_len = le16_to_cpu(temp_fea->value_len);
4123 /* BB validate that value_len falls within SMB,
4124 even though maximum for name_len is 255 */
4125 if(memcmp(temp_fea->name,ea_name,
4126 temp_fea->name_len) == 0) {
4127 /* found a match */
4128 rc = value_len;
4129 /* account for prefix user. and trailing null */
4130 if(rc<=(int)buf_size) {
4131 memcpy(ea_value,
4132 temp_fea->name+temp_fea->name_len+1,
4133 rc);
4134 /* ea values, unlike ea names,
4135 are not null terminated */
4136 } else if(buf_size == 0) {
4137 /* skip copy - calc size only */
4138 } else {
4139 /* stop before overrun buffer */
4140 rc = -ERANGE;
4141 }
4142 break;
4143 }
4144 name_len -= temp_fea->name_len;
4145 temp_ptr += temp_fea->name_len;
4146 /* account for trailing null */
4147 name_len--;
4148 temp_ptr++;
4149 name_len -= value_len;
4150 temp_ptr += value_len;
4151 /* no trailing null to account for in value len */
4152 /* go on to next EA */
4153 temp_fea = (struct fea *)temp_ptr;
4154 }
4155 }
4156 }
4157 }
4158 if (pSMB)
4159 cifs_buf_release(pSMB);
4160 if (rc == -EAGAIN)
4161 goto QEARetry;
4162
4163 return (ssize_t)rc;
4164}
4165
4166int
4167CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4168 const char * ea_name, const void * ea_value,
4169 const __u16 ea_value_len, const struct nls_table *nls_codepage)
4170{
4171 struct smb_com_transaction2_spi_req *pSMB = NULL;
4172 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4173 struct fealist *parm_data;
4174 int name_len;
4175 int rc = 0;
4176 int bytes_returned = 0;
4177 __u16 params, param_offset, byte_count, offset, count;
4178
4179 cFYI(1, ("In SetEA"));
4180SetEARetry:
4181 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4182 (void **) &pSMBr);
4183 if (rc)
4184 return rc;
4185
4186 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4187 name_len =
4188 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, PATH_MAX
4189 /* find define for this maxpathcomponent */
4190 , nls_codepage);
4191 name_len++; /* trailing null */
4192 name_len *= 2;
4193 } else { /* BB improve the check for buffer overruns BB */
4194 name_len = strnlen(fileName, PATH_MAX);
4195 name_len++; /* trailing null */
4196 strncpy(pSMB->FileName, fileName, name_len);
4197 }
4198
4199 params = 6 + name_len;
4200
4201 /* done calculating parms using name_len of file name,
4202 now use name_len to calculate length of ea name
4203 we are going to create in the inode xattrs */
4204 if(ea_name == NULL)
4205 name_len = 0;
4206 else
4207 name_len = strnlen(ea_name,255);
4208
4209 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
4210 pSMB->MaxParameterCount = cpu_to_le16(2);
4211 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
4212 pSMB->MaxSetupCount = 0;
4213 pSMB->Reserved = 0;
4214 pSMB->Flags = 0;
4215 pSMB->Timeout = 0;
4216 pSMB->Reserved2 = 0;
4217 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4218 InformationLevel) - 4;
4219 offset = param_offset + params;
4220 pSMB->InformationLevel =
4221 cpu_to_le16(SMB_SET_FILE_EA);
4222
4223 parm_data =
4224 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
4225 offset);
4226 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4227 pSMB->DataOffset = cpu_to_le16(offset);
4228 pSMB->SetupCount = 1;
4229 pSMB->Reserved3 = 0;
4230 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4231 byte_count = 3 /* pad */ + params + count;
4232 pSMB->DataCount = cpu_to_le16(count);
4233 parm_data->list_len = cpu_to_le32(count);
4234 parm_data->list[0].EA_flags = 0;
4235 /* we checked above that name len is less than 255 */
4236 parm_data->list[0].name_len = (__u8)name_len;;
4237 /* EA names are always ASCII */
4238 if(ea_name)
4239 strncpy(parm_data->list[0].name,ea_name,name_len);
4240 parm_data->list[0].name[name_len] = 0;
4241 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
4242 /* caller ensures that ea_value_len is less than 64K but
4243 we need to ensure that it fits within the smb */
4244
4245 /*BB add length check that it would fit in negotiated SMB buffer size BB */
4246 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
4247 if(ea_value_len)
4248 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
4249
4250 pSMB->TotalDataCount = pSMB->DataCount;
4251 pSMB->ParameterCount = cpu_to_le16(params);
4252 pSMB->TotalParameterCount = pSMB->ParameterCount;
4253 pSMB->Reserved4 = 0;
4254 pSMB->hdr.smb_buf_length += byte_count;
4255 pSMB->ByteCount = cpu_to_le16(byte_count);
4256 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4257 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4258 if (rc) {
4259 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
4260 }
4261
4262 cifs_buf_release(pSMB);
4263
4264 if (rc == -EAGAIN)
4265 goto SetEARetry;
4266
4267 return rc;
4268}
4269
4270#endif