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