?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CIFS] CIFS writepage improvements - eliminate double copy
[linux-2.6/verdex.git] / fs / cifs / cifssmb.c
blobb4f7b9859e3bedeb895a62d21ed44eda58354de8
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
42 static 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
51 static 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 */
63 static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
64 {
65 struct cifsFileInfo *open_file = NULL;
66 struct list_head * tmp;
67 struct list_head * tmp1;
68
69 /* list all files open on tree connection and mark them invalid */
70 write_lock(&GlobalSMBSeslock);
71 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
72 open_file = list_entry(tmp,struct cifsFileInfo, tlist);
73 if(open_file) {
74 open_file->invalidHandle = TRUE;
75 }
76 }
77 write_unlock(&GlobalSMBSeslock);
78 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted
79 to this tcon */
80 }
81
82 /* If the return code is zero, this function must fill in request_buf pointer */
83 static int
84 small_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) {
93 if((tcon->ses) && (tcon->ses->status != CifsExiting) &&
94 (tcon->ses->server)){
95 struct nls_table *nls_codepage;
96 /* Give Demultiplex thread up to 10 seconds to
97 reconnect, should be greater than cifs socket
98 timeout which is 7 seconds */
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;
108 } /* else "hard" mount - keep retrying
109 until process is killed or server
110 comes back on-line */
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)
121 rc = cifs_setup_session(0, tcon->ses,
122 nls_codepage);
123 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
124 mark_open_files_invalid(tcon);
125 rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon
126 , nls_codepage);
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 -
133 it is safer (and faster) to reopen files
134 one at a time as needed in read and write */
135
136 /* Check if handle based operation so we
137 know whether we can continue or not without
138 returning to caller to reset file handle */
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 */
178 static int
179 smb_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) {
189 if((tcon->ses) && (tcon->ses->status != CifsExiting) &&
190 (tcon->ses->server)){
191 struct nls_table *nls_codepage;
192 /* Give Demultiplex thread up to 10 seconds to
193 reconnect, should be greater than cifs socket
194 timeout which is 7 seconds */
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);
198 if(tcon->ses->server->tcpStatus ==
199 CifsNeedReconnect) {
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;
205 } /* else "hard" mount - keep retrying
206 until process is killed or server
207 comes on-line */
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)
218 rc = cifs_setup_session(0, tcon->ses,
219 nls_codepage);
220 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
221 mark_open_files_invalid(tcon);
222 rc = CIFSTCon(0, tcon->ses, tcon->treeName,
223 tcon, nls_codepage);
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 -
230 it is safer (and faster) to reopen files
231 one at a time as needed in read and write */
232
233 /* Check if handle based operation so we
234 know whether we can continue or not without
235 returning to caller to reset file handle */
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
280 static 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 */
297 pBCC = (pSMB->hdr.WordCount * 2) +
298 sizeof(struct smb_hdr) +
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 }
313 int
314 CIFSSMBNegotiate(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;
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 */
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,
388 ("UID of server does not match previous connection to same ip address"));
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
430 int
431 CIFSSMBTDis(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 }
468 rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
469 (void **)&smb_buffer);
470 if (rc) {
471 up(&tcon->tconSem);
472 return rc;
473 } else {
474 smb_buffer_response = smb_buffer; /* BB removeme BB */
475 }
476 rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
477 &length, 0);
478 if (rc)
479 cFYI(1, ("Tree disconnect failed %d", rc));
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
493 int
494 CIFSSMBLogoff(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
552 int
553 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon, const char *fileName,
554 const struct nls_table *nls_codepage, int remap)
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
562 DelFileRetry:
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 =
570 cifsConvertToUCS((__le16 *) pSMB->fileName, fileName,
571 PATH_MAX, nls_codepage, remap);
572 name_len++; /* trailing null */
573 name_len *= 2;
574 } else { /* BB improve check for buffer overruns BB */
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
602 int
603 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon, const char *dirName,
604 const struct nls_table *nls_codepage, int remap)
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"));
613 RmDirRetry:
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) {
620 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, dirName,
621 PATH_MAX, nls_codepage, remap);
622 name_len++; /* trailing null */
623 name_len *= 2;
624 } else { /* BB improve check for buffer overruns BB */
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
650 int
651 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
652 const char *name, const struct nls_table *nls_codepage, int remap)
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"));
661 MkDirRetry:
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) {
668 name_len = cifsConvertToUCS((__le16 *) pSMB->DirName, name,
669 PATH_MAX, nls_codepage, remap);
670 name_len++; /* trailing null */
671 name_len *= 2;
672 } else { /* BB improve check for buffer overruns BB */
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
697 int
698 CIFSSMBOpen(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,
702 const struct nls_table *nls_codepage, int remap)
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
711 openRetry:
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 =
722 cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
723 fileName, PATH_MAX, nls_codepage, remap);
724 name_len++; /* trailing null */
725 name_len *= 2;
726 pSMB->NameLength = cpu_to_le16(name_len);
727 } else { /* BB improve check for buffer overruns BB */
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);
756 /* BB Expirement with various impersonation levels and verify */
757 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
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 {
771 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
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
800 int
801 CIFSSMBRead(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
870 int
871 CIFSSMBWrite(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
954 int
955 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
956 const int netfid, const unsigned int count,
957 const __u64 offset, unsigned int *nbytes, const char *buf,
958 const int long_op)
959 {
960 int rc = -EACCES;
961 WRITE_REQ *pSMB = NULL;
962 int bytes_returned;
963 int smb_hdr_len;
964 __u32 bytes_sent;
965 __u16 byte_count;
966
967 cERROR(1,("write2 at %lld %d bytes",offset,count)); /* BB removeme BB */
968 rc = small_smb_init(SMB_COM_WRITE_ANDX, 14, tcon, (void **) &pSMB);
969 if (rc)
970 return rc;
971 /* tcon and ses pointer are checked in smb_init */
972 if (tcon->ses->server == NULL)
973 return -ECONNABORTED;
974
975 pSMB->AndXCommand = 0xFF; /* none */
976 pSMB->Fid = netfid;
977 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
978 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
979 pSMB->Reserved = 0xFFFFFFFF;
980 pSMB->WriteMode = 0;
981 pSMB->Remaining = 0;
982
983 /* Can increase buffer size if buffer is big enough in some cases - ie
984 can send more if LARGE_WRITE_X capability returned by the server and if
985 our buffer is big enough or if we convert to iovecs on socket writes
986 and eliminate the copy to the CIFS buffer */
987 if(tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
988 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
989 } else {
990 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
991 & ~0xFF;
992 }
993
994 if (bytes_sent > count)
995 bytes_sent = count;
996 pSMB->DataOffset =
997 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
998
999 byte_count = bytes_sent + 1 /* pad */ ; /* BB fix this for sends > 64K */
1000 pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1001 pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1002 smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1003 pSMB->hdr.smb_buf_length += bytes_sent+1;
1004 pSMB->ByteCount = cpu_to_le16(byte_count);
1005
1006 rc = SendReceive2(xid, tcon->ses, (struct smb_hdr *) pSMB, smb_hdr_len,
1007 buf, bytes_sent, &bytes_returned, long_op);
1008 if (rc) {
1009 cFYI(1, ("Send error in write = %d", rc));
1010 *nbytes = 0;
1011 } else {
1012 WRITE_RSP * pSMBr = (WRITE_RSP *)pSMB;
1013 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1014 *nbytes = (*nbytes) << 16;
1015 *nbytes += le16_to_cpu(pSMBr->Count);
1016 }
1017
1018 cifs_small_buf_release(pSMB);
1019
1020 /* Note: On -EAGAIN error only caller can retry on handle based calls
1021 since file handle passed in no longer valid */
1022
1023 return rc;
1024 }
1025
1026
1027 #endif /* CIFS_EXPERIMENTAL */
1028
1029 int
1030 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1031 const __u16 smb_file_id, const __u64 len,
1032 const __u64 offset, const __u32 numUnlock,
1033 const __u32 numLock, const __u8 lockType, const int waitFlag)
1034 {
1035 int rc = 0;
1036 LOCK_REQ *pSMB = NULL;
1037 LOCK_RSP *pSMBr = NULL;
1038 int bytes_returned;
1039 int timeout = 0;
1040 __u16 count;
1041
1042 cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
1043 rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1044
1045 if (rc)
1046 return rc;
1047
1048 pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
1049
1050 if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1051 timeout = -1; /* no response expected */
1052 pSMB->Timeout = 0;
1053 } else if (waitFlag == TRUE) {
1054 timeout = 3; /* blocking operation, no timeout */
1055 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1056 } else {
1057 pSMB->Timeout = 0;
1058 }
1059
1060 pSMB->NumberOfLocks = cpu_to_le16(numLock);
1061 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1062 pSMB->LockType = lockType;
1063 pSMB->AndXCommand = 0xFF; /* none */
1064 pSMB->Fid = smb_file_id; /* netfid stays le */
1065
1066 if((numLock != 0) || (numUnlock != 0)) {
1067 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1068 /* BB where to store pid high? */
1069 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1070 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1071 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1072 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1073 count = sizeof(LOCKING_ANDX_RANGE);
1074 } else {
1075 /* oplock break */
1076 count = 0;
1077 }
1078 pSMB->hdr.smb_buf_length += count;
1079 pSMB->ByteCount = cpu_to_le16(count);
1080
1081 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1082 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1083
1084 if (rc) {
1085 cFYI(1, ("Send error in Lock = %d", rc));
1086 }
1087 cifs_small_buf_release(pSMB);
1088
1089 /* Note: On -EAGAIN error only caller can retry on handle based calls
1090 since file handle passed in no longer valid */
1091 return rc;
1092 }
1093
1094 int
1095 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1096 {
1097 int rc = 0;
1098 CLOSE_REQ *pSMB = NULL;
1099 CLOSE_RSP *pSMBr = NULL;
1100 int bytes_returned;
1101 cFYI(1, ("In CIFSSMBClose"));
1102
1103 /* do not retry on dead session on close */
1104 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1105 if(rc == -EAGAIN)
1106 return 0;
1107 if (rc)
1108 return rc;
1109
1110 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
1111
1112 pSMB->FileID = (__u16) smb_file_id;
1113 pSMB->LastWriteTime = 0;
1114 pSMB->ByteCount = 0;
1115 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1116 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1117 if (rc) {
1118 if(rc!=-EINTR) {
1119 /* EINTR is expected when user ctl-c to kill app */
1120 cERROR(1, ("Send error in Close = %d", rc));
1121 }
1122 }
1123
1124 cifs_small_buf_release(pSMB);
1125
1126 /* Since session is dead, file will be closed on server already */
1127 if(rc == -EAGAIN)
1128 rc = 0;
1129
1130 return rc;
1131 }
1132
1133 int
1134 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1135 const char *fromName, const char *toName,
1136 const struct nls_table *nls_codepage, int remap)
1137 {
1138 int rc = 0;
1139 RENAME_REQ *pSMB = NULL;
1140 RENAME_RSP *pSMBr = NULL;
1141 int bytes_returned;
1142 int name_len, name_len2;
1143 __u16 count;
1144
1145 cFYI(1, ("In CIFSSMBRename"));
1146 renameRetry:
1147 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1148 (void **) &pSMBr);
1149 if (rc)
1150 return rc;
1151
1152 pSMB->BufferFormat = 0x04;
1153 pSMB->SearchAttributes =
1154 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1155 ATTR_DIRECTORY);
1156
1157 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1158 name_len =
1159 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1160 PATH_MAX, nls_codepage, remap);
1161 name_len++; /* trailing null */
1162 name_len *= 2;
1163 pSMB->OldFileName[name_len] = 0x04; /* pad */
1164 /* protocol requires ASCII signature byte on Unicode string */
1165 pSMB->OldFileName[name_len + 1] = 0x00;
1166 name_len2 =
1167 cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1168 toName, PATH_MAX, nls_codepage, remap);
1169 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1170 name_len2 *= 2; /* convert to bytes */
1171 } else { /* BB improve the check for buffer overruns BB */
1172 name_len = strnlen(fromName, PATH_MAX);
1173 name_len++; /* trailing null */
1174 strncpy(pSMB->OldFileName, fromName, name_len);
1175 name_len2 = strnlen(toName, PATH_MAX);
1176 name_len2++; /* trailing null */
1177 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1178 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1179 name_len2++; /* trailing null */
1180 name_len2++; /* signature byte */
1181 }
1182
1183 count = 1 /* 1st signature byte */ + name_len + name_len2;
1184 pSMB->hdr.smb_buf_length += count;
1185 pSMB->ByteCount = cpu_to_le16(count);
1186
1187 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1188 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1189 if (rc) {
1190 cFYI(1, ("Send error in rename = %d", rc));
1191 }
1192
1193 #ifdef CONFIG_CIFS_STATS
1194 else {
1195 atomic_inc(&tcon->num_renames);
1196 }
1197 #endif
1198
1199 cifs_buf_release(pSMB);
1200
1201 if (rc == -EAGAIN)
1202 goto renameRetry;
1203
1204 return rc;
1205 }
1206
1207 int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
1208 int netfid, char * target_name,
1209 const struct nls_table * nls_codepage, int remap)
1210 {
1211 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1212 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1213 struct set_file_rename * rename_info;
1214 char *data_offset;
1215 char dummy_string[30];
1216 int rc = 0;
1217 int bytes_returned = 0;
1218 int len_of_str;
1219 __u16 params, param_offset, offset, count, byte_count;
1220
1221 cFYI(1, ("Rename to File by handle"));
1222 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
1223 (void **) &pSMBr);
1224 if (rc)
1225 return rc;
1226
1227 params = 6;
1228 pSMB->MaxSetupCount = 0;
1229 pSMB->Reserved = 0;
1230 pSMB->Flags = 0;
1231 pSMB->Timeout = 0;
1232 pSMB->Reserved2 = 0;
1233 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1234 offset = param_offset + params;
1235
1236 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1237 rename_info = (struct set_file_rename *) data_offset;
1238 pSMB->MaxParameterCount = cpu_to_le16(2);
1239 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1240 pSMB->SetupCount = 1;
1241 pSMB->Reserved3 = 0;
1242 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1243 byte_count = 3 /* pad */ + params;
1244 pSMB->ParameterCount = cpu_to_le16(params);
1245 pSMB->TotalParameterCount = pSMB->ParameterCount;
1246 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1247 pSMB->DataOffset = cpu_to_le16(offset);
1248 /* construct random name ".cifs_tmp<inodenum><mid>" */
1249 rename_info->overwrite = cpu_to_le32(1);
1250 rename_info->root_fid = 0;
1251 /* unicode only call */
1252 if(target_name == NULL) {
1253 sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
1254 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1255 dummy_string, 24, nls_codepage, remap);
1256 } else {
1257 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1258 target_name, PATH_MAX, nls_codepage, remap);
1259 }
1260 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
1261 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
1262 byte_count += count;
1263 pSMB->DataCount = cpu_to_le16(count);
1264 pSMB->TotalDataCount = pSMB->DataCount;
1265 pSMB->Fid = netfid;
1266 pSMB->InformationLevel =
1267 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
1268 pSMB->Reserved4 = 0;
1269 pSMB->hdr.smb_buf_length += byte_count;
1270 pSMB->ByteCount = cpu_to_le16(byte_count);
1271 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
1272 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1273 if (rc) {
1274 cFYI(1,("Send error in Rename (by file handle) = %d", rc));
1275 }
1276 #ifdef CONFIG_CIFS_STATS
1277 else {
1278 atomic_inc(&pTcon->num_t2renames);
1279 }
1280 #endif
1281 cifs_buf_release(pSMB);
1282
1283 /* Note: On -EAGAIN error only caller can retry on handle based calls
1284 since file handle passed in no longer valid */
1285
1286 return rc;
1287 }
1288
1289 int
1290 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName,
1291 const __u16 target_tid, const char *toName, const int flags,
1292 const struct nls_table *nls_codepage, int remap)
1293 {
1294 int rc = 0;
1295 COPY_REQ *pSMB = NULL;
1296 COPY_RSP *pSMBr = NULL;
1297 int bytes_returned;
1298 int name_len, name_len2;
1299 __u16 count;
1300
1301 cFYI(1, ("In CIFSSMBCopy"));
1302 copyRetry:
1303 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
1304 (void **) &pSMBr);
1305 if (rc)
1306 return rc;
1307
1308 pSMB->BufferFormat = 0x04;
1309 pSMB->Tid2 = target_tid;
1310
1311 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
1312
1313 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1314 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
1315 fromName, PATH_MAX, nls_codepage,
1316 remap);
1317 name_len++; /* trailing null */
1318 name_len *= 2;
1319 pSMB->OldFileName[name_len] = 0x04; /* pad */
1320 /* protocol requires ASCII signature byte on Unicode string */
1321 pSMB->OldFileName[name_len + 1] = 0x00;
1322 name_len2 = cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1323 toName, PATH_MAX, nls_codepage, remap);
1324 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1325 name_len2 *= 2; /* convert to bytes */
1326 } else { /* BB improve the check for buffer overruns BB */
1327 name_len = strnlen(fromName, PATH_MAX);
1328 name_len++; /* trailing null */
1329 strncpy(pSMB->OldFileName, fromName, name_len);
1330 name_len2 = strnlen(toName, PATH_MAX);
1331 name_len2++; /* trailing null */
1332 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1333 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1334 name_len2++; /* trailing null */
1335 name_len2++; /* signature byte */
1336 }
1337
1338 count = 1 /* 1st signature byte */ + name_len + name_len2;
1339 pSMB->hdr.smb_buf_length += count;
1340 pSMB->ByteCount = cpu_to_le16(count);
1341
1342 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1343 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1344 if (rc) {
1345 cFYI(1, ("Send error in copy = %d with %d files copied",
1346 rc, le16_to_cpu(pSMBr->CopyCount)));
1347 }
1348 if (pSMB)
1349 cifs_buf_release(pSMB);
1350
1351 if (rc == -EAGAIN)
1352 goto copyRetry;
1353
1354 return rc;
1355 }
1356
1357 int
1358 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
1359 const char *fromName, const char *toName,
1360 const struct nls_table *nls_codepage)
1361 {
1362 TRANSACTION2_SPI_REQ *pSMB = NULL;
1363 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1364 char *data_offset;
1365 int name_len;
1366 int name_len_target;
1367 int rc = 0;
1368 int bytes_returned = 0;
1369 __u16 params, param_offset, offset, byte_count;
1370
1371 cFYI(1, ("In Symlink Unix style"));
1372 createSymLinkRetry:
1373 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1374 (void **) &pSMBr);
1375 if (rc)
1376 return rc;
1377
1378 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1379 name_len =
1380 cifs_strtoUCS((wchar_t *) pSMB->FileName, fromName, PATH_MAX
1381 /* find define for this maxpathcomponent */
1382 , nls_codepage);
1383 name_len++; /* trailing null */
1384 name_len *= 2;
1385
1386 } else { /* BB improve the check for buffer overruns BB */
1387 name_len = strnlen(fromName, PATH_MAX);
1388 name_len++; /* trailing null */
1389 strncpy(pSMB->FileName, fromName, name_len);
1390 }
1391 params = 6 + name_len;
1392 pSMB->MaxSetupCount = 0;
1393 pSMB->Reserved = 0;
1394 pSMB->Flags = 0;
1395 pSMB->Timeout = 0;
1396 pSMB->Reserved2 = 0;
1397 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1398 InformationLevel) - 4;
1399 offset = param_offset + params;
1400
1401 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1402 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1403 name_len_target =
1404 cifs_strtoUCS((wchar_t *) data_offset, toName, PATH_MAX
1405 /* find define for this maxpathcomponent */
1406 , nls_codepage);
1407 name_len_target++; /* trailing null */
1408 name_len_target *= 2;
1409 } else { /* BB improve the check for buffer overruns BB */
1410 name_len_target = strnlen(toName, PATH_MAX);
1411 name_len_target++; /* trailing null */
1412 strncpy(data_offset, toName, name_len_target);
1413 }
1414
1415 pSMB->MaxParameterCount = cpu_to_le16(2);
1416 /* BB find exact max on data count below from sess */
1417 pSMB->MaxDataCount = cpu_to_le16(1000);
1418 pSMB->SetupCount = 1;
1419 pSMB->Reserved3 = 0;
1420 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1421 byte_count = 3 /* pad */ + params + name_len_target;
1422 pSMB->DataCount = cpu_to_le16(name_len_target);
1423 pSMB->ParameterCount = cpu_to_le16(params);
1424 pSMB->TotalDataCount = pSMB->DataCount;
1425 pSMB->TotalParameterCount = pSMB->ParameterCount;
1426 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1427 pSMB->DataOffset = cpu_to_le16(offset);
1428 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
1429 pSMB->Reserved4 = 0;
1430 pSMB->hdr.smb_buf_length += byte_count;
1431 pSMB->ByteCount = cpu_to_le16(byte_count);
1432 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1433 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1434 if (rc) {
1435 cFYI(1,
1436 ("Send error in SetPathInfo (create symlink) = %d",
1437 rc));
1438 }
1439
1440 if (pSMB)
1441 cifs_buf_release(pSMB);
1442
1443 if (rc == -EAGAIN)
1444 goto createSymLinkRetry;
1445
1446 return rc;
1447 }
1448
1449 int
1450 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1451 const char *fromName, const char *toName,
1452 const struct nls_table *nls_codepage, int remap)
1453 {
1454 TRANSACTION2_SPI_REQ *pSMB = NULL;
1455 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1456 char *data_offset;
1457 int name_len;
1458 int name_len_target;
1459 int rc = 0;
1460 int bytes_returned = 0;
1461 __u16 params, param_offset, offset, byte_count;
1462
1463 cFYI(1, ("In Create Hard link Unix style"));
1464 createHardLinkRetry:
1465 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1466 (void **) &pSMBr);
1467 if (rc)
1468 return rc;
1469
1470 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1471 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
1472 PATH_MAX, nls_codepage, remap);
1473 name_len++; /* trailing null */
1474 name_len *= 2;
1475
1476 } else { /* BB improve the check for buffer overruns BB */
1477 name_len = strnlen(toName, PATH_MAX);
1478 name_len++; /* trailing null */
1479 strncpy(pSMB->FileName, toName, name_len);
1480 }
1481 params = 6 + name_len;
1482 pSMB->MaxSetupCount = 0;
1483 pSMB->Reserved = 0;
1484 pSMB->Flags = 0;
1485 pSMB->Timeout = 0;
1486 pSMB->Reserved2 = 0;
1487 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1488 InformationLevel) - 4;
1489 offset = param_offset + params;
1490
1491 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1492 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1493 name_len_target =
1494 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
1495 nls_codepage, remap);
1496 name_len_target++; /* trailing null */
1497 name_len_target *= 2;
1498 } else { /* BB improve the check for buffer overruns BB */
1499 name_len_target = strnlen(fromName, PATH_MAX);
1500 name_len_target++; /* trailing null */
1501 strncpy(data_offset, fromName, name_len_target);
1502 }
1503
1504 pSMB->MaxParameterCount = cpu_to_le16(2);
1505 /* BB find exact max on data count below from sess*/
1506 pSMB->MaxDataCount = cpu_to_le16(1000);
1507 pSMB->SetupCount = 1;
1508 pSMB->Reserved3 = 0;
1509 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1510 byte_count = 3 /* pad */ + params + name_len_target;
1511 pSMB->ParameterCount = cpu_to_le16(params);
1512 pSMB->TotalParameterCount = pSMB->ParameterCount;
1513 pSMB->DataCount = cpu_to_le16(name_len_target);
1514 pSMB->TotalDataCount = pSMB->DataCount;
1515 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1516 pSMB->DataOffset = cpu_to_le16(offset);
1517 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
1518 pSMB->Reserved4 = 0;
1519 pSMB->hdr.smb_buf_length += byte_count;
1520 pSMB->ByteCount = cpu_to_le16(byte_count);
1521 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1522 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1523 if (rc) {
1524 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
1525 }
1526
1527 cifs_buf_release(pSMB);
1528 if (rc == -EAGAIN)
1529 goto createHardLinkRetry;
1530
1531 return rc;
1532 }
1533
1534 int
1535 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1536 const char *fromName, const char *toName,
1537 const struct nls_table *nls_codepage, int remap)
1538 {
1539 int rc = 0;
1540 NT_RENAME_REQ *pSMB = NULL;
1541 RENAME_RSP *pSMBr = NULL;
1542 int bytes_returned;
1543 int name_len, name_len2;
1544 __u16 count;
1545
1546 cFYI(1, ("In CIFSCreateHardLink"));
1547 winCreateHardLinkRetry:
1548
1549 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
1550 (void **) &pSMBr);
1551 if (rc)
1552 return rc;
1553
1554 pSMB->SearchAttributes =
1555 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1556 ATTR_DIRECTORY);
1557 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
1558 pSMB->ClusterCount = 0;
1559
1560 pSMB->BufferFormat = 0x04;
1561
1562 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1563 name_len =
1564 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1565 PATH_MAX, nls_codepage, remap);
1566 name_len++; /* trailing null */
1567 name_len *= 2;
1568 pSMB->OldFileName[name_len] = 0; /* pad */
1569 pSMB->OldFileName[name_len + 1] = 0x04;
1570 name_len2 =
1571 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1572 toName, PATH_MAX, nls_codepage, remap);
1573 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1574 name_len2 *= 2; /* convert to bytes */
1575 } else { /* BB improve the check for buffer overruns BB */
1576 name_len = strnlen(fromName, PATH_MAX);
1577 name_len++; /* trailing null */
1578 strncpy(pSMB->OldFileName, fromName, name_len);
1579 name_len2 = strnlen(toName, PATH_MAX);
1580 name_len2++; /* trailing null */
1581 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1582 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1583 name_len2++; /* trailing null */
1584 name_len2++; /* signature byte */
1585 }
1586
1587 count = 1 /* string type byte */ + name_len + name_len2;
1588 pSMB->hdr.smb_buf_length += count;
1589 pSMB->ByteCount = cpu_to_le16(count);
1590
1591 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1592 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1593 if (rc) {
1594 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
1595 }
1596 cifs_buf_release(pSMB);
1597 if (rc == -EAGAIN)
1598 goto winCreateHardLinkRetry;
1599
1600 return rc;
1601 }
1602
1603 int
1604 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
1605 const unsigned char *searchName,
1606 char *symlinkinfo, const int buflen,
1607 const struct nls_table *nls_codepage)
1608 {
1609 /* SMB_QUERY_FILE_UNIX_LINK */
1610 TRANSACTION2_QPI_REQ *pSMB = NULL;
1611 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1612 int rc = 0;
1613 int bytes_returned;
1614 int name_len;
1615 __u16 params, byte_count;
1616
1617 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
1618
1619 querySymLinkRetry:
1620 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1621 (void **) &pSMBr);
1622 if (rc)
1623 return rc;
1624
1625 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1626 name_len =
1627 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, PATH_MAX
1628 /* find define for this maxpathcomponent */
1629 , nls_codepage);
1630 name_len++; /* trailing null */
1631 name_len *= 2;
1632 } else { /* BB improve the check for buffer overruns BB */
1633 name_len = strnlen(searchName, PATH_MAX);
1634 name_len++; /* trailing null */
1635 strncpy(pSMB->FileName, searchName, name_len);
1636 }
1637
1638 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1639 pSMB->TotalDataCount = 0;
1640 pSMB->MaxParameterCount = cpu_to_le16(2);
1641 /* BB find exact max data count below from sess structure BB */
1642 pSMB->MaxDataCount = cpu_to_le16(4000);
1643 pSMB->MaxSetupCount = 0;
1644 pSMB->Reserved = 0;
1645 pSMB->Flags = 0;
1646 pSMB->Timeout = 0;
1647 pSMB->Reserved2 = 0;
1648 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1649 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1650 pSMB->DataCount = 0;
1651 pSMB->DataOffset = 0;
1652 pSMB->SetupCount = 1;
1653 pSMB->Reserved3 = 0;
1654 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1655 byte_count = params + 1 /* pad */ ;
1656 pSMB->TotalParameterCount = cpu_to_le16(params);
1657 pSMB->ParameterCount = pSMB->TotalParameterCount;
1658 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
1659 pSMB->Reserved4 = 0;
1660 pSMB->hdr.smb_buf_length += byte_count;
1661 pSMB->ByteCount = cpu_to_le16(byte_count);
1662
1663 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1664 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1665 if (rc) {
1666 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
1667 } else {
1668 /* decode response */
1669
1670 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1671 if (rc || (pSMBr->ByteCount < 2))
1672 /* BB also check enough total bytes returned */
1673 rc = -EIO; /* bad smb */
1674 else {
1675 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1676 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
1677
1678 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1679 name_len = UniStrnlen((wchar_t *) ((char *)
1680 &pSMBr->hdr.Protocol +data_offset),
1681 min_t(const int, buflen,count) / 2);
1682 /* BB FIXME investigate remapping reserved chars here */
1683 cifs_strfromUCS_le(symlinkinfo,
1684 (wchar_t *) ((char *)&pSMBr->hdr.Protocol +
1685 data_offset),
1686 name_len, nls_codepage);
1687 } else {
1688 strncpy(symlinkinfo,
1689 (char *) &pSMBr->hdr.Protocol +
1690 data_offset,
1691 min_t(const int, buflen, count));
1692 }
1693 symlinkinfo[buflen] = 0;
1694 /* just in case so calling code does not go off the end of buffer */
1695 }
1696 }
1697 cifs_buf_release(pSMB);
1698 if (rc == -EAGAIN)
1699 goto querySymLinkRetry;
1700 return rc;
1701 }
1702
1703 int
1704 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
1705 const unsigned char *searchName,
1706 char *symlinkinfo, const int buflen,__u16 fid,
1707 const struct nls_table *nls_codepage)
1708 {
1709 int rc = 0;
1710 int bytes_returned;
1711 int name_len;
1712 struct smb_com_transaction_ioctl_req * pSMB;
1713 struct smb_com_transaction_ioctl_rsp * pSMBr;
1714
1715 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
1716 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
1717 (void **) &pSMBr);
1718 if (rc)
1719 return rc;
1720
1721 pSMB->TotalParameterCount = 0 ;
1722 pSMB->TotalDataCount = 0;
1723 pSMB->MaxParameterCount = cpu_to_le32(2);
1724 /* BB find exact data count max from sess structure BB */
1725 pSMB->MaxDataCount = cpu_to_le32(4000);
1726 pSMB->MaxSetupCount = 4;
1727 pSMB->Reserved = 0;
1728 pSMB->ParameterOffset = 0;
1729 pSMB->DataCount = 0;
1730 pSMB->DataOffset = 0;
1731 pSMB->SetupCount = 4;
1732 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
1733 pSMB->ParameterCount = pSMB->TotalParameterCount;
1734 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
1735 pSMB->IsFsctl = 1; /* FSCTL */
1736 pSMB->IsRootFlag = 0;
1737 pSMB->Fid = fid; /* file handle always le */
1738 pSMB->ByteCount = 0;
1739
1740 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1741 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1742 if (rc) {
1743 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
1744 } else { /* decode response */
1745 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
1746 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
1747 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
1748 /* BB also check enough total bytes returned */
1749 rc = -EIO; /* bad smb */
1750 else {
1751 if(data_count && (data_count < 2048)) {
1752 char * end_of_smb = pSMBr->ByteCount + (char *)&pSMBr->ByteCount;
1753
1754 struct reparse_data * reparse_buf = (struct reparse_data *)
1755 ((char *)&pSMBr->hdr.Protocol + data_offset);
1756 if((char*)reparse_buf >= end_of_smb) {
1757 rc = -EIO;
1758 goto qreparse_out;
1759 }
1760 if((reparse_buf->LinkNamesBuf +
1761 reparse_buf->TargetNameOffset +
1762 reparse_buf->TargetNameLen) >
1763 end_of_smb) {
1764 cFYI(1,("reparse buf extended beyond SMB"));
1765 rc = -EIO;
1766 goto qreparse_out;
1767 }
1768
1769 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1770 name_len = UniStrnlen((wchar_t *)
1771 (reparse_buf->LinkNamesBuf +
1772 reparse_buf->TargetNameOffset),
1773 min(buflen/2, reparse_buf->TargetNameLen / 2));
1774 cifs_strfromUCS_le(symlinkinfo,
1775 (wchar_t *) (reparse_buf->LinkNamesBuf +
1776 reparse_buf->TargetNameOffset),
1777 name_len, nls_codepage);
1778 } else { /* ASCII names */
1779 strncpy(symlinkinfo,reparse_buf->LinkNamesBuf +
1780 reparse_buf->TargetNameOffset,
1781 min_t(const int, buflen, reparse_buf->TargetNameLen));
1782 }
1783 } else {
1784 rc = -EIO;
1785 cFYI(1,("Invalid return data count on get reparse info ioctl"));
1786 }
1787 symlinkinfo[buflen] = 0; /* just in case so the caller
1788 does not go off the end of the buffer */
1789 cFYI(1,("readlink result - %s ",symlinkinfo));
1790 }
1791 }
1792 qreparse_out:
1793 if (pSMB)
1794 cifs_buf_release(pSMB);
1795
1796 /* Note: On -EAGAIN error only caller can retry on handle based calls
1797 since file handle passed in no longer valid */
1798
1799 return rc;
1800 }
1801
1802 #ifdef CONFIG_CIFS_POSIX
1803
1804 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
1805 static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace * cifs_ace)
1806 {
1807 /* u8 cifs fields do not need le conversion */
1808 ace->e_perm = (__u16)cifs_ace->cifs_e_perm;
1809 ace->e_tag = (__u16)cifs_ace->cifs_e_tag;
1810 ace->e_id = (__u32)le64_to_cpu(cifs_ace->cifs_uid);
1811 /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
1812
1813 return;
1814 }
1815
1816 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
1817 static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
1818 const int acl_type,const int size_of_data_area)
1819 {
1820 int size = 0;
1821 int i;
1822 __u16 count;
1823 struct cifs_posix_ace * pACE;
1824 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)src;
1825 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)trgt;
1826
1827 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
1828 return -EOPNOTSUPP;
1829
1830 if(acl_type & ACL_TYPE_ACCESS) {
1831 count = le16_to_cpu(cifs_acl->access_entry_count);
1832 pACE = &cifs_acl->ace_array[0];
1833 size = sizeof(struct cifs_posix_acl);
1834 size += sizeof(struct cifs_posix_ace) * count;
1835 /* check if we would go beyond end of SMB */
1836 if(size_of_data_area < size) {
1837 cFYI(1,("bad CIFS POSIX ACL size %d vs. %d",size_of_data_area,size));
1838 return -EINVAL;
1839 }
1840 } else if(acl_type & ACL_TYPE_DEFAULT) {
1841 count = le16_to_cpu(cifs_acl->access_entry_count);
1842 size = sizeof(struct cifs_posix_acl);
1843 size += sizeof(struct cifs_posix_ace) * count;
1844 /* skip past access ACEs to get to default ACEs */
1845 pACE = &cifs_acl->ace_array[count];
1846 count = le16_to_cpu(cifs_acl->default_entry_count);
1847 size += sizeof(struct cifs_posix_ace) * count;
1848 /* check if we would go beyond end of SMB */
1849 if(size_of_data_area < size)
1850 return -EINVAL;
1851 } else {
1852 /* illegal type */
1853 return -EINVAL;
1854 }
1855
1856 size = posix_acl_xattr_size(count);
1857 if((buflen == 0) || (local_acl == NULL)) {
1858 /* used to query ACL EA size */
1859 } else if(size > buflen) {
1860 return -ERANGE;
1861 } else /* buffer big enough */ {
1862 local_acl->a_version = POSIX_ACL_XATTR_VERSION;
1863 for(i = 0;i < count ;i++) {
1864 cifs_convert_ace(&local_acl->a_entries[i],pACE);
1865 pACE ++;
1866 }
1867 }
1868 return size;
1869 }
1870
1871 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace * cifs_ace,
1872 const posix_acl_xattr_entry * local_ace)
1873 {
1874 __u16 rc = 0; /* 0 = ACL converted ok */
1875
1876 cifs_ace->cifs_e_perm = (__u8)cpu_to_le16(local_ace->e_perm);
1877 cifs_ace->cifs_e_tag = (__u8)cpu_to_le16(local_ace->e_tag);
1878 /* BB is there a better way to handle the large uid? */
1879 if(local_ace->e_id == -1) {
1880 /* Probably no need to le convert -1 on any arch but can not hurt */
1881 cifs_ace->cifs_uid = cpu_to_le64(-1);
1882 } else
1883 cifs_ace->cifs_uid = (__u64)cpu_to_le32(local_ace->e_id);
1884 /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
1885 return rc;
1886 }
1887
1888 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
1889 static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int buflen,
1890 const int acl_type)
1891 {
1892 __u16 rc = 0;
1893 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)parm_data;
1894 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)pACL;
1895 int count;
1896 int i;
1897
1898 if((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
1899 return 0;
1900
1901 count = posix_acl_xattr_count((size_t)buflen);
1902 cFYI(1,("setting acl with %d entries from buf of length %d and version of %d",
1903 count,buflen,local_acl->a_version));
1904 if(local_acl->a_version != 2) {
1905 cFYI(1,("unknown POSIX ACL version %d",local_acl->a_version));
1906 return 0;
1907 }
1908 cifs_acl->version = cpu_to_le16(1);
1909 if(acl_type == ACL_TYPE_ACCESS)
1910 cifs_acl->access_entry_count = count;
1911 else if(acl_type == ACL_TYPE_DEFAULT)
1912 cifs_acl->default_entry_count = count;
1913 else {
1914 cFYI(1,("unknown ACL type %d",acl_type));
1915 return 0;
1916 }
1917 for(i=0;i<count;i++) {
1918 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
1919 &local_acl->a_entries[i]);
1920 if(rc != 0) {
1921 /* ACE not converted */
1922 break;
1923 }
1924 }
1925 if(rc == 0) {
1926 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
1927 rc += sizeof(struct cifs_posix_acl);
1928 /* BB add check to make sure ACL does not overflow SMB */
1929 }
1930 return rc;
1931 }
1932
1933 int
1934 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
1935 const unsigned char *searchName,
1936 char *acl_inf, const int buflen, const int acl_type,
1937 const struct nls_table *nls_codepage, int remap)
1938 {
1939 /* SMB_QUERY_POSIX_ACL */
1940 TRANSACTION2_QPI_REQ *pSMB = NULL;
1941 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1942 int rc = 0;
1943 int bytes_returned;
1944 int name_len;
1945 __u16 params, byte_count;
1946
1947 cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
1948
1949 queryAclRetry:
1950 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1951 (void **) &pSMBr);
1952 if (rc)
1953 return rc;
1954
1955 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1956 name_len =
1957 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
1958 PATH_MAX, nls_codepage, remap);
1959 name_len++; /* trailing null */
1960 name_len *= 2;
1961 pSMB->FileName[name_len] = 0;
1962 pSMB->FileName[name_len+1] = 0;
1963 } else { /* BB improve the check for buffer overruns BB */
1964 name_len = strnlen(searchName, PATH_MAX);
1965 name_len++; /* trailing null */
1966 strncpy(pSMB->FileName, searchName, name_len);
1967 }
1968
1969 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1970 pSMB->TotalDataCount = 0;
1971 pSMB->MaxParameterCount = cpu_to_le16(2);
1972 /* BB find exact max data count below from sess structure BB */
1973 pSMB->MaxDataCount = cpu_to_le16(4000);
1974 pSMB->MaxSetupCount = 0;
1975 pSMB->Reserved = 0;
1976 pSMB->Flags = 0;
1977 pSMB->Timeout = 0;
1978 pSMB->Reserved2 = 0;
1979 pSMB->ParameterOffset = cpu_to_le16(
1980 offsetof(struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1981 pSMB->DataCount = 0;
1982 pSMB->DataOffset = 0;
1983 pSMB->SetupCount = 1;
1984 pSMB->Reserved3 = 0;
1985 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1986 byte_count = params + 1 /* pad */ ;
1987 pSMB->TotalParameterCount = cpu_to_le16(params);
1988 pSMB->ParameterCount = pSMB->TotalParameterCount;
1989 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
1990 pSMB->Reserved4 = 0;
1991 pSMB->hdr.smb_buf_length += byte_count;
1992 pSMB->ByteCount = cpu_to_le16(byte_count);
1993
1994 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1995 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1996 if (rc) {
1997 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
1998 } else {
1999 /* decode response */
2000
2001 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2002 if (rc || (pSMBr->ByteCount < 2))
2003 /* BB also check enough total bytes returned */
2004 rc = -EIO; /* bad smb */
2005 else {
2006 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2007 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2008 rc = cifs_copy_posix_acl(acl_inf,
2009 (char *)&pSMBr->hdr.Protocol+data_offset,
2010 buflen,acl_type,count);
2011 }
2012 }
2013 cifs_buf_release(pSMB);
2014 if (rc == -EAGAIN)
2015 goto queryAclRetry;
2016 return rc;
2017 }
2018
2019 int
2020 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2021 const unsigned char *fileName,
2022 const char *local_acl, const int buflen,
2023 const int acl_type,
2024 const struct nls_table *nls_codepage, int remap)
2025 {
2026 struct smb_com_transaction2_spi_req *pSMB = NULL;
2027 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2028 char *parm_data;
2029 int name_len;
2030 int rc = 0;
2031 int bytes_returned = 0;
2032 __u16 params, byte_count, data_count, param_offset, offset;
2033
2034 cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2035 setAclRetry:
2036 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2037 (void **) &pSMBr);
2038 if (rc)
2039 return rc;
2040 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2041 name_len =
2042 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2043 PATH_MAX, nls_codepage, remap);
2044 name_len++; /* trailing null */
2045 name_len *= 2;
2046 } else { /* BB improve the check for buffer overruns BB */
2047 name_len = strnlen(fileName, PATH_MAX);
2048 name_len++; /* trailing null */
2049 strncpy(pSMB->FileName, fileName, name_len);
2050 }
2051 params = 6 + name_len;
2052 pSMB->MaxParameterCount = cpu_to_le16(2);
2053 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2054 pSMB->MaxSetupCount = 0;
2055 pSMB->Reserved = 0;
2056 pSMB->Flags = 0;
2057 pSMB->Timeout = 0;
2058 pSMB->Reserved2 = 0;
2059 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2060 InformationLevel) - 4;
2061 offset = param_offset + params;
2062 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2063 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2064
2065 /* convert to on the wire format for POSIX ACL */
2066 data_count = ACL_to_cifs_posix(parm_data,local_acl,buflen,acl_type);
2067
2068 if(data_count == 0) {
2069 rc = -EOPNOTSUPP;
2070 goto setACLerrorExit;
2071 }
2072 pSMB->DataOffset = cpu_to_le16(offset);
2073 pSMB->SetupCount = 1;
2074 pSMB->Reserved3 = 0;
2075 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2076 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2077 byte_count = 3 /* pad */ + params + data_count;
2078 pSMB->DataCount = cpu_to_le16(data_count);
2079 pSMB->TotalDataCount = pSMB->DataCount;
2080 pSMB->ParameterCount = cpu_to_le16(params);
2081 pSMB->TotalParameterCount = pSMB->ParameterCount;
2082 pSMB->Reserved4 = 0;
2083 pSMB->hdr.smb_buf_length += byte_count;
2084 pSMB->ByteCount = cpu_to_le16(byte_count);
2085 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2086 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2087 if (rc) {
2088 cFYI(1, ("Set POSIX ACL returned %d", rc));
2089 }
2090
2091 setACLerrorExit:
2092 cifs_buf_release(pSMB);
2093 if (rc == -EAGAIN)
2094 goto setAclRetry;
2095 return rc;
2096 }
2097
2098 /* BB fix tabs in this function FIXME BB */
2099 int
2100 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2101 const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
2102 {
2103 int rc = 0;
2104 struct smb_t2_qfi_req *pSMB = NULL;
2105 struct smb_t2_qfi_rsp *pSMBr = NULL;
2106 int bytes_returned;
2107 __u16 params, byte_count;
2108
2109 cFYI(1,("In GetExtAttr"));
2110 if(tcon == NULL)
2111 return -ENODEV;
2112
2113 GetExtAttrRetry:
2114 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2115 (void **) &pSMBr);
2116 if (rc)
2117 return rc;
2118
2119 params = 2 /* level */ +2 /* fid */;
2120 pSMB->t2.TotalDataCount = 0;
2121 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
2122 /* BB find exact max data count below from sess structure BB */
2123 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
2124 pSMB->t2.MaxSetupCount = 0;
2125 pSMB->t2.Reserved = 0;
2126 pSMB->t2.Flags = 0;
2127 pSMB->t2.Timeout = 0;
2128 pSMB->t2.Reserved2 = 0;
2129 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
2130 Fid) - 4);
2131 pSMB->t2.DataCount = 0;
2132 pSMB->t2.DataOffset = 0;
2133 pSMB->t2.SetupCount = 1;
2134 pSMB->t2.Reserved3 = 0;
2135 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2136 byte_count = params + 1 /* pad */ ;
2137 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
2138 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
2139 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
2140 pSMB->Pad = 0;
2141 pSMB->Fid = netfid;
2142 pSMB->hdr.smb_buf_length += byte_count;
2143 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
2144
2145 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2146 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2147 if (rc) {
2148 cFYI(1, ("error %d in GetExtAttr", rc));
2149 } else {
2150 /* decode response */
2151 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2152 if (rc || (pSMBr->ByteCount < 2))
2153 /* BB also check enough total bytes returned */
2154 /* If rc should we check for EOPNOSUPP and
2155 disable the srvino flag? or in caller? */
2156 rc = -EIO; /* bad smb */
2157 else {
2158 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2159 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2160 struct file_chattr_info * pfinfo;
2161 /* BB Do we need a cast or hash here ? */
2162 if(count != 16) {
2163 cFYI(1, ("Illegal size ret in GetExtAttr"));
2164 rc = -EIO;
2165 goto GetExtAttrOut;
2166 }
2167 pfinfo = (struct file_chattr_info *)
2168 (data_offset + (char *) &pSMBr->hdr.Protocol);
2169 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
2170 *pMask = le64_to_cpu(pfinfo->mask);
2171 }
2172 }
2173 GetExtAttrOut:
2174 cifs_buf_release(pSMB);
2175 if (rc == -EAGAIN)
2176 goto GetExtAttrRetry;
2177 return rc;
2178 }
2179
2180
2181 #endif /* CONFIG_POSIX */
2182
2183 int
2184 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
2185 const unsigned char *searchName,
2186 FILE_ALL_INFO * pFindData,
2187 const struct nls_table *nls_codepage, int remap)
2188 {
2189 /* level 263 SMB_QUERY_FILE_ALL_INFO */
2190 TRANSACTION2_QPI_REQ *pSMB = NULL;
2191 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2192 int rc = 0;
2193 int bytes_returned;
2194 int name_len;
2195 __u16 params, byte_count;
2196
2197 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
2198 QPathInfoRetry:
2199 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2200 (void **) &pSMBr);
2201 if (rc)
2202 return rc;
2203
2204 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2205 name_len =
2206 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2207 PATH_MAX, nls_codepage, remap);
2208 name_len++; /* trailing null */
2209 name_len *= 2;
2210 } else { /* BB improve the check for buffer overruns BB */
2211 name_len = strnlen(searchName, PATH_MAX);
2212 name_len++; /* trailing null */
2213 strncpy(pSMB->FileName, searchName, name_len);
2214 }
2215
2216 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2217 pSMB->TotalDataCount = 0;
2218 pSMB->MaxParameterCount = cpu_to_le16(2);
2219 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2220 pSMB->MaxSetupCount = 0;
2221 pSMB->Reserved = 0;
2222 pSMB->Flags = 0;
2223 pSMB->Timeout = 0;
2224 pSMB->Reserved2 = 0;
2225 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2226 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2227 pSMB->DataCount = 0;
2228 pSMB->DataOffset = 0;
2229 pSMB->SetupCount = 1;
2230 pSMB->Reserved3 = 0;
2231 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2232 byte_count = params + 1 /* pad */ ;
2233 pSMB->TotalParameterCount = cpu_to_le16(params);
2234 pSMB->ParameterCount = pSMB->TotalParameterCount;
2235 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
2236 pSMB->Reserved4 = 0;
2237 pSMB->hdr.smb_buf_length += byte_count;
2238 pSMB->ByteCount = cpu_to_le16(byte_count);
2239
2240 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2241 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2242 if (rc) {
2243 cFYI(1, ("Send error in QPathInfo = %d", rc));
2244 } else { /* decode response */
2245 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2246
2247 if (rc || (pSMBr->ByteCount < 40))
2248 rc = -EIO; /* bad smb */
2249 else if (pFindData){
2250 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2251 memcpy((char *) pFindData,
2252 (char *) &pSMBr->hdr.Protocol +
2253 data_offset, sizeof (FILE_ALL_INFO));
2254 } else
2255 rc = -ENOMEM;
2256 }
2257 cifs_buf_release(pSMB);
2258 if (rc == -EAGAIN)
2259 goto QPathInfoRetry;
2260
2261 return rc;
2262 }
2263
2264 int
2265 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
2266 const unsigned char *searchName,
2267 FILE_UNIX_BASIC_INFO * pFindData,
2268 const struct nls_table *nls_codepage, int remap)
2269 {
2270 /* SMB_QUERY_FILE_UNIX_BASIC */
2271 TRANSACTION2_QPI_REQ *pSMB = NULL;
2272 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2273 int rc = 0;
2274 int bytes_returned = 0;
2275 int name_len;
2276 __u16 params, byte_count;
2277
2278 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
2279 UnixQPathInfoRetry:
2280 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2281 (void **) &pSMBr);
2282 if (rc)
2283 return rc;
2284
2285 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2286 name_len =
2287 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2288 PATH_MAX, nls_codepage, remap);
2289 name_len++; /* trailing null */
2290 name_len *= 2;
2291 } else { /* BB improve the check for buffer overruns BB */
2292 name_len = strnlen(searchName, PATH_MAX);
2293 name_len++; /* trailing null */
2294 strncpy(pSMB->FileName, searchName, name_len);
2295 }
2296
2297 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2298 pSMB->TotalDataCount = 0;
2299 pSMB->MaxParameterCount = cpu_to_le16(2);
2300 /* BB find exact max SMB PDU from sess structure BB */
2301 pSMB->MaxDataCount = cpu_to_le16(4000);
2302 pSMB->MaxSetupCount = 0;
2303 pSMB->Reserved = 0;
2304 pSMB->Flags = 0;
2305 pSMB->Timeout = 0;
2306 pSMB->Reserved2 = 0;
2307 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2308 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2309 pSMB->DataCount = 0;
2310 pSMB->DataOffset = 0;
2311 pSMB->SetupCount = 1;
2312 pSMB->Reserved3 = 0;
2313 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2314 byte_count = params + 1 /* pad */ ;
2315 pSMB->TotalParameterCount = cpu_to_le16(params);
2316 pSMB->ParameterCount = pSMB->TotalParameterCount;
2317 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
2318 pSMB->Reserved4 = 0;
2319 pSMB->hdr.smb_buf_length += byte_count;
2320 pSMB->ByteCount = cpu_to_le16(byte_count);
2321
2322 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2323 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2324 if (rc) {
2325 cFYI(1, ("Send error in QPathInfo = %d", rc));
2326 } else { /* decode response */
2327 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2328
2329 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
2330 rc = -EIO; /* bad smb */
2331 } else {
2332 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2333 memcpy((char *) pFindData,
2334 (char *) &pSMBr->hdr.Protocol +
2335 data_offset,
2336 sizeof (FILE_UNIX_BASIC_INFO));
2337 }
2338 }
2339 cifs_buf_release(pSMB);
2340 if (rc == -EAGAIN)
2341 goto UnixQPathInfoRetry;
2342
2343 return rc;
2344 }
2345
2346 #if 0 /* function unused at present */
2347 int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
2348 const char *searchName, FILE_ALL_INFO * findData,
2349 const struct nls_table *nls_codepage)
2350 {
2351 /* level 257 SMB_ */
2352 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2353 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2354 int rc = 0;
2355 int bytes_returned;
2356 int name_len;
2357 __u16 params, byte_count;
2358
2359 cFYI(1, ("In FindUnique"));
2360 findUniqueRetry:
2361 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2362 (void **) &pSMBr);
2363 if (rc)
2364 return rc;
2365
2366 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2367 name_len =
2368 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
2369 /* find define for this maxpathcomponent */
2370 , nls_codepage);
2371 name_len++; /* trailing null */
2372 name_len *= 2;
2373 } else { /* BB improve the check for buffer overruns BB */
2374 name_len = strnlen(searchName, PATH_MAX);
2375 name_len++; /* trailing null */
2376 strncpy(pSMB->FileName, searchName, name_len);
2377 }
2378
2379 params = 12 + name_len /* includes null */ ;
2380 pSMB->TotalDataCount = 0; /* no EAs */
2381 pSMB->MaxParameterCount = cpu_to_le16(2);
2382 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2383 pSMB->MaxSetupCount = 0;
2384 pSMB->Reserved = 0;
2385 pSMB->Flags = 0;
2386 pSMB->Timeout = 0;
2387 pSMB->Reserved2 = 0;
2388 pSMB->ParameterOffset = cpu_to_le16(
2389 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
2390 pSMB->DataCount = 0;
2391 pSMB->DataOffset = 0;
2392 pSMB->SetupCount = 1; /* one byte, no need to le convert */
2393 pSMB->Reserved3 = 0;
2394 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2395 byte_count = params + 1 /* pad */ ;
2396 pSMB->TotalParameterCount = cpu_to_le16(params);
2397 pSMB->ParameterCount = pSMB->TotalParameterCount;
2398 pSMB->SearchAttributes =
2399 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2400 ATTR_DIRECTORY);
2401 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
2402 pSMB->SearchFlags = cpu_to_le16(1);
2403 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2404 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
2405 pSMB->hdr.smb_buf_length += byte_count;
2406 pSMB->ByteCount = cpu_to_le16(byte_count);
2407
2408 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2409 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2410
2411 if (rc) {
2412 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
2413 } else { /* decode response */
2414
2415 /* BB fill in */
2416 }
2417
2418 cifs_buf_release(pSMB);
2419 if (rc == -EAGAIN)
2420 goto findUniqueRetry;
2421
2422 return rc;
2423 }
2424 #endif /* end unused (temporarily) function */
2425
2426 /* xid, tcon, searchName and codepage are input parms, rest are returned */
2427 int
2428 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
2429 const char *searchName,
2430 const struct nls_table *nls_codepage,
2431 __u16 * pnetfid,
2432 struct cifs_search_info * psrch_inf, int remap)
2433 {
2434 /* level 257 SMB_ */
2435 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
2436 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
2437 T2_FFIRST_RSP_PARMS * parms;
2438 int rc = 0;
2439 int bytes_returned = 0;
2440 int name_len;
2441 __u16 params, byte_count;
2442
2443 cFYI(1, ("In FindFirst for %s",searchName));
2444
2445 findFirstRetry:
2446 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2447 (void **) &pSMBr);
2448 if (rc)
2449 return rc;
2450
2451 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2452 name_len =
2453 cifsConvertToUCS((__le16 *) pSMB->FileName,searchName,
2454 PATH_MAX, nls_codepage, remap);
2455 /* We can not add the asterik earlier in case
2456 it got remapped to 0xF03A as if it were part of the
2457 directory name instead of a wildcard */
2458 name_len *= 2;
2459 pSMB->FileName[name_len] = '\\';
2460 pSMB->FileName[name_len+1] = 0;
2461 pSMB->FileName[name_len+2] = '*';
2462 pSMB->FileName[name_len+3] = 0;
2463 name_len += 4; /* now the trailing null */
2464 pSMB->FileName[name_len] = 0; /* null terminate just in case */
2465 pSMB->FileName[name_len+1] = 0;
2466 name_len += 2;
2467 } else { /* BB add check for overrun of SMB buf BB */
2468 name_len = strnlen(searchName, PATH_MAX);
2469 /* BB fix here and in unicode clause above ie
2470 if(name_len > buffersize-header)
2471 free buffer exit; BB */
2472 strncpy(pSMB->FileName, searchName, name_len);
2473 pSMB->FileName[name_len] = '\\';
2474 pSMB->FileName[name_len+1] = '*';
2475 pSMB->FileName[name_len+2] = 0;
2476 name_len += 3;
2477 }
2478
2479 params = 12 + name_len /* includes null */ ;
2480 pSMB->TotalDataCount = 0; /* no EAs */
2481 pSMB->MaxParameterCount = cpu_to_le16(10);
2482 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
2483 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2484 pSMB->MaxSetupCount = 0;
2485 pSMB->Reserved = 0;
2486 pSMB->Flags = 0;
2487 pSMB->Timeout = 0;
2488 pSMB->Reserved2 = 0;
2489 byte_count = params + 1 /* pad */ ;
2490 pSMB->TotalParameterCount = cpu_to_le16(params);
2491 pSMB->ParameterCount = pSMB->TotalParameterCount;
2492 pSMB->ParameterOffset = cpu_to_le16(
2493 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
2494 pSMB->DataCount = 0;
2495 pSMB->DataOffset = 0;
2496 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
2497 pSMB->Reserved3 = 0;
2498 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
2499 pSMB->SearchAttributes =
2500 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2501 ATTR_DIRECTORY);
2502 pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
2503 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
2504 CIFS_SEARCH_RETURN_RESUME);
2505 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2506
2507 /* BB what should we set StorageType to? Does it matter? BB */
2508 pSMB->SearchStorageType = 0;
2509 pSMB->hdr.smb_buf_length += byte_count;
2510 pSMB->ByteCount = cpu_to_le16(byte_count);
2511
2512 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2513 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2514
2515 if (rc) {/* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
2516 /* BB Add code to handle unsupported level rc */
2517 cFYI(1, ("Error in FindFirst = %d", rc));
2518
2519 if (pSMB)
2520 cifs_buf_release(pSMB);
2521
2522 /* BB eventually could optimize out free and realloc of buf */
2523 /* for this case */
2524 if (rc == -EAGAIN)
2525 goto findFirstRetry;
2526 } else { /* decode response */
2527 /* BB remember to free buffer if error BB */
2528 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2529 if(rc == 0) {
2530 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2531 psrch_inf->unicode = TRUE;
2532 else
2533 psrch_inf->unicode = FALSE;
2534
2535 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
2536 psrch_inf->srch_entries_start =
2537 (char *) &pSMBr->hdr.Protocol +
2538 le16_to_cpu(pSMBr->t2.DataOffset);
2539 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
2540 le16_to_cpu(pSMBr->t2.ParameterOffset));
2541
2542 if(parms->EndofSearch)
2543 psrch_inf->endOfSearch = TRUE;
2544 else
2545 psrch_inf->endOfSearch = FALSE;
2546
2547 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2548 psrch_inf->index_of_last_entry =
2549 psrch_inf->entries_in_buffer;
2550 *pnetfid = parms->SearchHandle;
2551 } else {
2552 cifs_buf_release(pSMB);
2553 }
2554 }
2555
2556 return rc;
2557 }
2558
2559 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
2560 __u16 searchHandle, struct cifs_search_info * psrch_inf)
2561 {
2562 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
2563 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
2564 T2_FNEXT_RSP_PARMS * parms;
2565 char *response_data;
2566 int rc = 0;
2567 int bytes_returned, name_len;
2568 __u16 params, byte_count;
2569
2570 cFYI(1, ("In FindNext"));
2571
2572 if(psrch_inf->endOfSearch == TRUE)
2573 return -ENOENT;
2574
2575 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2576 (void **) &pSMBr);
2577 if (rc)
2578 return rc;
2579
2580 params = 14; /* includes 2 bytes of null string, converted to LE below */
2581 byte_count = 0;
2582 pSMB->TotalDataCount = 0; /* no EAs */
2583 pSMB->MaxParameterCount = cpu_to_le16(8);
2584 pSMB->MaxDataCount =
2585 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2586 pSMB->MaxSetupCount = 0;
2587 pSMB->Reserved = 0;
2588 pSMB->Flags = 0;
2589 pSMB->Timeout = 0;
2590 pSMB->Reserved2 = 0;
2591 pSMB->ParameterOffset = cpu_to_le16(
2592 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
2593 pSMB->DataCount = 0;
2594 pSMB->DataOffset = 0;
2595 pSMB->SetupCount = 1;
2596 pSMB->Reserved3 = 0;
2597 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
2598 pSMB->SearchHandle = searchHandle; /* always kept as le */
2599 pSMB->SearchCount =
2600 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
2601 /* test for Unix extensions */
2602 /* if (tcon->ses->capabilities & CAP_UNIX) {
2603 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
2604 psrch_inf->info_level = SMB_FIND_FILE_UNIX;
2605 } else {
2606 pSMB->InformationLevel =
2607 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
2608 psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
2609 } */
2610 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
2611 pSMB->ResumeKey = psrch_inf->resume_key;
2612 pSMB->SearchFlags =
2613 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
2614
2615 name_len = psrch_inf->resume_name_len;
2616 params += name_len;
2617 if(name_len < PATH_MAX) {
2618 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
2619 byte_count += name_len;
2620 } else {
2621 rc = -EINVAL;
2622 goto FNext2_err_exit;
2623 }
2624 byte_count = params + 1 /* pad */ ;
2625 pSMB->TotalParameterCount = cpu_to_le16(params);
2626 pSMB->ParameterCount = pSMB->TotalParameterCount;
2627 pSMB->hdr.smb_buf_length += byte_count;
2628 pSMB->ByteCount = cpu_to_le16(byte_count);
2629
2630 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2631 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2632
2633 if (rc) {
2634 if (rc == -EBADF) {
2635 psrch_inf->endOfSearch = TRUE;
2636 rc = 0; /* search probably was closed at end of search above */
2637 } else
2638 cFYI(1, ("FindNext returned = %d", rc));
2639 } else { /* decode response */
2640 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2641
2642 if(rc == 0) {
2643 /* BB fixme add lock for file (srch_info) struct here */
2644 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
2645 psrch_inf->unicode = TRUE;
2646 else
2647 psrch_inf->unicode = FALSE;
2648 response_data = (char *) &pSMBr->hdr.Protocol +
2649 le16_to_cpu(pSMBr->t2.ParameterOffset);
2650 parms = (T2_FNEXT_RSP_PARMS *)response_data;
2651 response_data = (char *)&pSMBr->hdr.Protocol +
2652 le16_to_cpu(pSMBr->t2.DataOffset);
2653 cifs_buf_release(psrch_inf->ntwrk_buf_start);
2654 psrch_inf->srch_entries_start = response_data;
2655 psrch_inf->ntwrk_buf_start = (char *)pSMB;
2656 if(parms->EndofSearch)
2657 psrch_inf->endOfSearch = TRUE;
2658 else
2659 psrch_inf->endOfSearch = FALSE;
2660
2661 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
2662 psrch_inf->index_of_last_entry +=
2663 psrch_inf->entries_in_buffer;
2664 /* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
2665
2666 /* BB fixme add unlock here */
2667 }
2668
2669 }
2670
2671 /* BB On error, should we leave previous search buf (and count and
2672 last entry fields) intact or free the previous one? */
2673
2674 /* Note: On -EAGAIN error only caller can retry on handle based calls
2675 since file handle passed in no longer valid */
2676 FNext2_err_exit:
2677 if (rc != 0)
2678 cifs_buf_release(pSMB);
2679
2680 return rc;
2681 }
2682
2683 int
2684 CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
2685 {
2686 int rc = 0;
2687 FINDCLOSE_REQ *pSMB = NULL;
2688 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
2689 int bytes_returned;
2690
2691 cFYI(1, ("In CIFSSMBFindClose"));
2692 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
2693
2694 /* no sense returning error if session restarted
2695 as file handle has been closed */
2696 if(rc == -EAGAIN)
2697 return 0;
2698 if (rc)
2699 return rc;
2700
2701 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
2702 pSMB->FileID = searchHandle;
2703 pSMB->ByteCount = 0;
2704 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2705 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2706 if (rc) {
2707 cERROR(1, ("Send error in FindClose = %d", rc));
2708 }
2709 cifs_small_buf_release(pSMB);
2710
2711 /* Since session is dead, search handle closed on server already */
2712 if (rc == -EAGAIN)
2713 rc = 0;
2714
2715 return rc;
2716 }
2717
2718 #ifdef CONFIG_CIFS_EXPERIMENTAL
2719 int
2720 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
2721 const unsigned char *searchName,
2722 __u64 * inode_number,
2723 const struct nls_table *nls_codepage, int remap)
2724 {
2725 int rc = 0;
2726 TRANSACTION2_QPI_REQ *pSMB = NULL;
2727 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2728 int name_len, bytes_returned;
2729 __u16 params, byte_count;
2730
2731 cFYI(1,("In GetSrvInodeNum for %s",searchName));
2732 if(tcon == NULL)
2733 return -ENODEV;
2734
2735 GetInodeNumberRetry:
2736 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2737 (void **) &pSMBr);
2738 if (rc)
2739 return rc;
2740
2741
2742 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2743 name_len =
2744 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2745 PATH_MAX,nls_codepage, remap);
2746 name_len++; /* trailing null */
2747 name_len *= 2;
2748 } else { /* BB improve the check for buffer overruns BB */
2749 name_len = strnlen(searchName, PATH_MAX);
2750 name_len++; /* trailing null */
2751 strncpy(pSMB->FileName, searchName, name_len);
2752 }
2753
2754 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2755 pSMB->TotalDataCount = 0;
2756 pSMB->MaxParameterCount = cpu_to_le16(2);
2757 /* BB find exact max data count below from sess structure BB */
2758 pSMB->MaxDataCount = cpu_to_le16(4000);
2759 pSMB->MaxSetupCount = 0;
2760 pSMB->Reserved = 0;
2761 pSMB->Flags = 0;
2762 pSMB->Timeout = 0;
2763 pSMB->Reserved2 = 0;
2764 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2765 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2766 pSMB->DataCount = 0;
2767 pSMB->DataOffset = 0;
2768 pSMB->SetupCount = 1;
2769 pSMB->Reserved3 = 0;
2770 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2771 byte_count = params + 1 /* pad */ ;
2772 pSMB->TotalParameterCount = cpu_to_le16(params);
2773 pSMB->ParameterCount = pSMB->TotalParameterCount;
2774 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
2775 pSMB->Reserved4 = 0;
2776 pSMB->hdr.smb_buf_length += byte_count;
2777 pSMB->ByteCount = cpu_to_le16(byte_count);
2778
2779 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2780 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2781 if (rc) {
2782 cFYI(1, ("error %d in QueryInternalInfo", rc));
2783 } else {
2784 /* decode response */
2785 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2786 if (rc || (pSMBr->ByteCount < 2))
2787 /* BB also check enough total bytes returned */
2788 /* If rc should we check for EOPNOSUPP and
2789 disable the srvino flag? or in caller? */
2790 rc = -EIO; /* bad smb */
2791 else {
2792 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2793 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2794 struct file_internal_info * pfinfo;
2795 /* BB Do we need a cast or hash here ? */
2796 if(count < 8) {
2797 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
2798 rc = -EIO;
2799 goto GetInodeNumOut;
2800 }
2801 pfinfo = (struct file_internal_info *)
2802 (data_offset + (char *) &pSMBr->hdr.Protocol);
2803 *inode_number = pfinfo->UniqueId;
2804 }
2805 }
2806 GetInodeNumOut:
2807 cifs_buf_release(pSMB);
2808 if (rc == -EAGAIN)
2809 goto GetInodeNumberRetry;
2810 return rc;
2811 }
2812 #endif /* CIFS_EXPERIMENTAL */
2813
2814 int
2815 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
2816 const unsigned char *searchName,
2817 unsigned char **targetUNCs,
2818 unsigned int *number_of_UNC_in_array,
2819 const struct nls_table *nls_codepage, int remap)
2820 {
2821 /* TRANS2_GET_DFS_REFERRAL */
2822 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
2823 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
2824 struct dfs_referral_level_3 * referrals = NULL;
2825 int rc = 0;
2826 int bytes_returned;
2827 int name_len;
2828 unsigned int i;
2829 char * temp;
2830 __u16 params, byte_count;
2831 *number_of_UNC_in_array = 0;
2832 *targetUNCs = NULL;
2833
2834 cFYI(1, ("In GetDFSRefer the path %s", searchName));
2835 if (ses == NULL)
2836 return -ENODEV;
2837 getDFSRetry:
2838 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
2839 (void **) &pSMBr);
2840 if (rc)
2841 return rc;
2842
2843 pSMB->hdr.Tid = ses->ipc_tid;
2844 pSMB->hdr.Uid = ses->Suid;
2845 if (ses->capabilities & CAP_STATUS32) {
2846 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
2847 }
2848 if (ses->capabilities & CAP_DFS) {
2849 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
2850 }
2851
2852 if (ses->capabilities & CAP_UNICODE) {
2853 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
2854 name_len =
2855 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
2856 searchName, PATH_MAX, nls_codepage, remap);
2857 name_len++; /* trailing null */
2858 name_len *= 2;
2859 } else { /* BB improve the check for buffer overruns BB */
2860 name_len = strnlen(searchName, PATH_MAX);
2861 name_len++; /* trailing null */
2862 strncpy(pSMB->RequestFileName, searchName, name_len);
2863 }
2864
2865 params = 2 /* level */ + name_len /*includes null */ ;
2866 pSMB->TotalDataCount = 0;
2867 pSMB->DataCount = 0;
2868 pSMB->DataOffset = 0;
2869 pSMB->MaxParameterCount = 0;
2870 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2871 pSMB->MaxSetupCount = 0;
2872 pSMB->Reserved = 0;
2873 pSMB->Flags = 0;
2874 pSMB->Timeout = 0;
2875 pSMB->Reserved2 = 0;
2876 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2877 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
2878 pSMB->SetupCount = 1;
2879 pSMB->Reserved3 = 0;
2880 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
2881 byte_count = params + 3 /* pad */ ;
2882 pSMB->ParameterCount = cpu_to_le16(params);
2883 pSMB->TotalParameterCount = pSMB->ParameterCount;
2884 pSMB->MaxReferralLevel = cpu_to_le16(3);
2885 pSMB->hdr.smb_buf_length += byte_count;
2886 pSMB->ByteCount = cpu_to_le16(byte_count);
2887
2888 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
2889 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2890 if (rc) {
2891 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
2892 } else { /* decode response */
2893 /* BB Add logic to parse referrals here */
2894 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2895
2896 if (rc || (pSMBr->ByteCount < 17)) /* BB also check enough total bytes returned */
2897 rc = -EIO; /* bad smb */
2898 else {
2899 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2900 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
2901
2902 cFYI(1,
2903 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
2904 pSMBr->ByteCount, data_offset));
2905 referrals =
2906 (struct dfs_referral_level_3 *)
2907 (8 /* sizeof start of data block */ +
2908 data_offset +
2909 (char *) &pSMBr->hdr.Protocol);
2910 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",
2911 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)));
2912 /* BB This field is actually two bytes in from start of
2913 data block so we could do safety check that DataBlock
2914 begins at address of pSMBr->NumberOfReferrals */
2915 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
2916
2917 /* BB Fix below so can return more than one referral */
2918 if(*number_of_UNC_in_array > 1)
2919 *number_of_UNC_in_array = 1;
2920
2921 /* get the length of the strings describing refs */
2922 name_len = 0;
2923 for(i=0;i<*number_of_UNC_in_array;i++) {
2924 /* make sure that DfsPathOffset not past end */
2925 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
2926 if (offset > data_count) {
2927 /* if invalid referral, stop here and do
2928 not try to copy any more */
2929 *number_of_UNC_in_array = i;
2930 break;
2931 }
2932 temp = ((char *)referrals) + offset;
2933
2934 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2935 name_len += UniStrnlen((wchar_t *)temp,data_count);
2936 } else {
2937 name_len += strnlen(temp,data_count);
2938 }
2939 referrals++;
2940 /* BB add check that referral pointer does not fall off end PDU */
2941
2942 }
2943 /* BB add check for name_len bigger than bcc */
2944 *targetUNCs =
2945 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
2946 if(*targetUNCs == NULL) {
2947 rc = -ENOMEM;
2948 goto GetDFSRefExit;
2949 }
2950 /* copy the ref strings */
2951 referrals =
2952 (struct dfs_referral_level_3 *)
2953 (8 /* sizeof data hdr */ +
2954 data_offset +
2955 (char *) &pSMBr->hdr.Protocol);
2956
2957 for(i=0;i<*number_of_UNC_in_array;i++) {
2958 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
2959 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2960 cifs_strfromUCS_le(*targetUNCs,
2961 (wchar_t *) temp, name_len, nls_codepage);
2962 } else {
2963 strncpy(*targetUNCs,temp,name_len);
2964 }
2965 /* BB update target_uncs pointers */
2966 referrals++;
2967 }
2968 temp = *targetUNCs;
2969 temp[name_len] = 0;
2970 }
2971
2972 }
2973 GetDFSRefExit:
2974 if (pSMB)
2975 cifs_buf_release(pSMB);
2976
2977 if (rc == -EAGAIN)
2978 goto getDFSRetry;
2979
2980 return rc;
2981 }
2982
2983 int
2984 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
2985 {
2986 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
2987 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2988 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2989 FILE_SYSTEM_INFO *response_data;
2990 int rc = 0;
2991 int bytes_returned = 0;
2992 __u16 params, byte_count;
2993
2994 cFYI(1, ("In QFSInfo"));
2995 QFSInfoRetry:
2996 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2997 (void **) &pSMBr);
2998 if (rc)
2999 return rc;
3000
3001 params = 2; /* level */
3002 pSMB->TotalDataCount = 0;
3003 pSMB->MaxParameterCount = cpu_to_le16(2);
3004 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3005 pSMB->MaxSetupCount = 0;
3006 pSMB->Reserved = 0;
3007 pSMB->Flags = 0;
3008 pSMB->Timeout = 0;
3009 pSMB->Reserved2 = 0;
3010 byte_count = params + 1 /* pad */ ;
3011 pSMB->TotalParameterCount = cpu_to_le16(params);
3012 pSMB->ParameterCount = pSMB->TotalParameterCount;
3013 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3014 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3015 pSMB->DataCount = 0;
3016 pSMB->DataOffset = 0;
3017 pSMB->SetupCount = 1;
3018 pSMB->Reserved3 = 0;
3019 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3020 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
3021 pSMB->hdr.smb_buf_length += byte_count;
3022 pSMB->ByteCount = cpu_to_le16(byte_count);
3023
3024 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3025 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3026 if (rc) {
3027 cERROR(1, ("Send error in QFSInfo = %d", rc));
3028 } else { /* decode response */
3029 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3030
3031 if (rc || (pSMBr->ByteCount < 24)) /* BB alsO CHEck enough total bytes returned */
3032 rc = -EIO; /* bad smb */
3033 else {
3034 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3035 cFYI(1,
3036 ("Decoding qfsinfo response. BCC: %d Offset %d",
3037 pSMBr->ByteCount, data_offset));
3038
3039 response_data =
3040 (FILE_SYSTEM_INFO
3041 *) (((char *) &pSMBr->hdr.Protocol) +
3042 data_offset);
3043 FSData->f_bsize =
3044 le32_to_cpu(response_data->BytesPerSector) *
3045 le32_to_cpu(response_data->
3046 SectorsPerAllocationUnit);
3047 FSData->f_blocks =
3048 le64_to_cpu(response_data->TotalAllocationUnits);
3049 FSData->f_bfree = FSData->f_bavail =
3050 le64_to_cpu(response_data->FreeAllocationUnits);
3051 cFYI(1,
3052 ("Blocks: %lld Free: %lld Block size %ld",
3053 (unsigned long long)FSData->f_blocks,
3054 (unsigned long long)FSData->f_bfree,
3055 FSData->f_bsize));
3056 }
3057 }
3058 cifs_buf_release(pSMB);
3059
3060 if (rc == -EAGAIN)
3061 goto QFSInfoRetry;
3062
3063 return rc;
3064 }
3065
3066 int
3067 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
3068 {
3069 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
3070 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3071 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3072 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
3073 int rc = 0;
3074 int bytes_returned = 0;
3075 __u16 params, byte_count;
3076
3077 cFYI(1, ("In QFSAttributeInfo"));
3078 QFSAttributeRetry:
3079 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3080 (void **) &pSMBr);
3081 if (rc)
3082 return rc;
3083
3084 params = 2; /* level */
3085 pSMB->TotalDataCount = 0;
3086 pSMB->MaxParameterCount = cpu_to_le16(2);
3087 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3088 pSMB->MaxSetupCount = 0;
3089 pSMB->Reserved = 0;
3090 pSMB->Flags = 0;
3091 pSMB->Timeout = 0;
3092 pSMB->Reserved2 = 0;
3093 byte_count = params + 1 /* pad */ ;
3094 pSMB->TotalParameterCount = cpu_to_le16(params);
3095 pSMB->ParameterCount = pSMB->TotalParameterCount;
3096 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3097 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3098 pSMB->DataCount = 0;
3099 pSMB->DataOffset = 0;
3100 pSMB->SetupCount = 1;
3101 pSMB->Reserved3 = 0;
3102 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3103 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
3104 pSMB->hdr.smb_buf_length += byte_count;
3105 pSMB->ByteCount = cpu_to_le16(byte_count);
3106
3107 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3108 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3109 if (rc) {
3110 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
3111 } else { /* decode response */
3112 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3113
3114 if (rc || (pSMBr->ByteCount < 13)) { /* BB also check enough bytes returned */
3115 rc = -EIO; /* bad smb */
3116 } else {
3117 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3118 response_data =
3119 (FILE_SYSTEM_ATTRIBUTE_INFO
3120 *) (((char *) &pSMBr->hdr.Protocol) +
3121 data_offset);
3122 memcpy(&tcon->fsAttrInfo, response_data,
3123 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
3124 }
3125 }
3126 cifs_buf_release(pSMB);
3127
3128 if (rc == -EAGAIN)
3129 goto QFSAttributeRetry;
3130
3131 return rc;
3132 }
3133
3134 int
3135 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
3136 {
3137 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
3138 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3139 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3140 FILE_SYSTEM_DEVICE_INFO *response_data;
3141 int rc = 0;
3142 int bytes_returned = 0;
3143 __u16 params, byte_count;
3144
3145 cFYI(1, ("In QFSDeviceInfo"));
3146 QFSDeviceRetry:
3147 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3148 (void **) &pSMBr);
3149 if (rc)
3150 return rc;
3151
3152 params = 2; /* level */
3153 pSMB->TotalDataCount = 0;
3154 pSMB->MaxParameterCount = cpu_to_le16(2);
3155 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3156 pSMB->MaxSetupCount = 0;
3157 pSMB->Reserved = 0;
3158 pSMB->Flags = 0;
3159 pSMB->Timeout = 0;
3160 pSMB->Reserved2 = 0;
3161 byte_count = params + 1 /* pad */ ;
3162 pSMB->TotalParameterCount = cpu_to_le16(params);
3163 pSMB->ParameterCount = pSMB->TotalParameterCount;
3164 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3165 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3166
3167 pSMB->DataCount = 0;
3168 pSMB->DataOffset = 0;
3169 pSMB->SetupCount = 1;
3170 pSMB->Reserved3 = 0;
3171 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3172 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
3173 pSMB->hdr.smb_buf_length += byte_count;
3174 pSMB->ByteCount = cpu_to_le16(byte_count);
3175
3176 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3177 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3178 if (rc) {
3179 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
3180 } else { /* decode response */
3181 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3182
3183 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
3184 rc = -EIO; /* bad smb */
3185 else {
3186 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3187 response_data =
3188 (FILE_SYSTEM_DEVICE_INFO *)
3189 (((char *) &pSMBr->hdr.Protocol) +
3190 data_offset);
3191 memcpy(&tcon->fsDevInfo, response_data,
3192 sizeof (FILE_SYSTEM_DEVICE_INFO));
3193 }
3194 }
3195 cifs_buf_release(pSMB);
3196
3197 if (rc == -EAGAIN)
3198 goto QFSDeviceRetry;
3199
3200 return rc;
3201 }
3202
3203 int
3204 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
3205 {
3206 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
3207 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3208 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3209 FILE_SYSTEM_UNIX_INFO *response_data;
3210 int rc = 0;
3211 int bytes_returned = 0;
3212 __u16 params, byte_count;
3213
3214 cFYI(1, ("In QFSUnixInfo"));
3215 QFSUnixRetry:
3216 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3217 (void **) &pSMBr);
3218 if (rc)
3219 return rc;
3220
3221 params = 2; /* level */
3222 pSMB->TotalDataCount = 0;
3223 pSMB->DataCount = 0;
3224 pSMB->DataOffset = 0;
3225 pSMB->MaxParameterCount = cpu_to_le16(2);
3226 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3227 pSMB->MaxSetupCount = 0;
3228 pSMB->Reserved = 0;
3229 pSMB->Flags = 0;
3230 pSMB->Timeout = 0;
3231 pSMB->Reserved2 = 0;
3232 byte_count = params + 1 /* pad */ ;
3233 pSMB->ParameterCount = cpu_to_le16(params);
3234 pSMB->TotalParameterCount = pSMB->ParameterCount;
3235 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3236 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3237 pSMB->SetupCount = 1;
3238 pSMB->Reserved3 = 0;
3239 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3240 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
3241 pSMB->hdr.smb_buf_length += byte_count;
3242 pSMB->ByteCount = cpu_to_le16(byte_count);
3243
3244 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3245 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3246 if (rc) {
3247 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
3248 } else { /* decode response */
3249 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3250
3251 if (rc || (pSMBr->ByteCount < 13)) {
3252 rc = -EIO; /* bad smb */
3253 } else {
3254 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3255 response_data =
3256 (FILE_SYSTEM_UNIX_INFO
3257 *) (((char *) &pSMBr->hdr.Protocol) +
3258 data_offset);
3259 memcpy(&tcon->fsUnixInfo, response_data,
3260 sizeof (FILE_SYSTEM_UNIX_INFO));
3261 }
3262 }
3263 cifs_buf_release(pSMB);
3264
3265 if (rc == -EAGAIN)
3266 goto QFSUnixRetry;
3267
3268
3269 return rc;
3270 }
3271
3272
3273 int
3274 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
3275 struct kstatfs *FSData)
3276 {
3277 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
3278 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3279 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3280 FILE_SYSTEM_POSIX_INFO *response_data;
3281 int rc = 0;
3282 int bytes_returned = 0;
3283 __u16 params, byte_count;
3284
3285 cFYI(1, ("In QFSPosixInfo"));
3286 QFSPosixRetry:
3287 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3288 (void **) &pSMBr);
3289 if (rc)
3290 return rc;
3291
3292 params = 2; /* level */
3293 pSMB->TotalDataCount = 0;
3294 pSMB->DataCount = 0;
3295 pSMB->DataOffset = 0;
3296 pSMB->MaxParameterCount = cpu_to_le16(2);
3297 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
3298 pSMB->MaxSetupCount = 0;
3299 pSMB->Reserved = 0;
3300 pSMB->Flags = 0;
3301 pSMB->Timeout = 0;
3302 pSMB->Reserved2 = 0;
3303 byte_count = params + 1 /* pad */ ;
3304 pSMB->ParameterCount = cpu_to_le16(params);
3305 pSMB->TotalParameterCount = pSMB->ParameterCount;
3306 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
3307 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3308 pSMB->SetupCount = 1;
3309 pSMB->Reserved3 = 0;
3310 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3311 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
3312 pSMB->hdr.smb_buf_length += byte_count;
3313 pSMB->ByteCount = cpu_to_le16(byte_count);
3314
3315 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3316 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3317 if (rc) {
3318 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
3319 } else { /* decode response */
3320 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3321
3322 if (rc || (pSMBr->ByteCount < 13)) {
3323 rc = -EIO; /* bad smb */
3324 } else {
3325 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3326 response_data =
3327 (FILE_SYSTEM_POSIX_INFO
3328 *) (((char *) &pSMBr->hdr.Protocol) +
3329 data_offset);
3330 FSData->f_bsize =
3331 le32_to_cpu(response_data->BlockSize);
3332 FSData->f_blocks =
3333 le64_to_cpu(response_data->TotalBlocks);
3334 FSData->f_bfree =
3335 le64_to_cpu(response_data->BlocksAvail);
3336 if(response_data->UserBlocksAvail == -1) {
3337 FSData->f_bavail = FSData->f_bfree;
3338 } else {
3339 FSData->f_bavail =
3340 le64_to_cpu(response_data->UserBlocksAvail);
3341 }
3342 if(response_data->TotalFileNodes != -1)
3343 FSData->f_files =
3344 le64_to_cpu(response_data->TotalFileNodes);
3345 if(response_data->FreeFileNodes != -1)
3346 FSData->f_ffree =
3347 le64_to_cpu(response_data->FreeFileNodes);
3348 }
3349 }
3350 cifs_buf_release(pSMB);
3351
3352 if (rc == -EAGAIN)
3353 goto QFSPosixRetry;
3354
3355 return rc;
3356 }
3357
3358
3359 /* We can not use write of zero bytes trick to
3360 set file size due to need for large file support. Also note that
3361 this SetPathInfo is preferred to SetFileInfo based method in next
3362 routine which is only needed to work around a sharing violation bug
3363 in Samba which this routine can run into */
3364
3365 int
3366 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3367 __u64 size, int SetAllocation,
3368 const struct nls_table *nls_codepage, int remap)
3369 {
3370 struct smb_com_transaction2_spi_req *pSMB = NULL;
3371 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3372 struct file_end_of_file_info *parm_data;
3373 int name_len;
3374 int rc = 0;
3375 int bytes_returned = 0;
3376 __u16 params, byte_count, data_count, param_offset, offset;
3377
3378 cFYI(1, ("In SetEOF"));
3379 SetEOFRetry:
3380 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3381 (void **) &pSMBr);
3382 if (rc)
3383 return rc;
3384
3385 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3386 name_len =
3387 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
3388 PATH_MAX, nls_codepage, remap);
3389 name_len++; /* trailing null */
3390 name_len *= 2;
3391 } else { /* BB improve the check for buffer overruns BB */
3392 name_len = strnlen(fileName, PATH_MAX);
3393 name_len++; /* trailing null */
3394 strncpy(pSMB->FileName, fileName, name_len);
3395 }
3396 params = 6 + name_len;
3397 data_count = sizeof (struct file_end_of_file_info);
3398 pSMB->MaxParameterCount = cpu_to_le16(2);
3399 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
3400 pSMB->MaxSetupCount = 0;
3401 pSMB->Reserved = 0;
3402 pSMB->Flags = 0;
3403 pSMB->Timeout = 0;
3404 pSMB->Reserved2 = 0;
3405 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3406 InformationLevel) - 4;
3407 offset = param_offset + params;
3408 if(SetAllocation) {
3409 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3410 pSMB->InformationLevel =
3411 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3412 else
3413 pSMB->InformationLevel =
3414 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3415 } else /* Set File Size */ {
3416 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3417 pSMB->InformationLevel =
3418 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3419 else
3420 pSMB->InformationLevel =
3421 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3422 }
3423
3424 parm_data =
3425 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3426 offset);
3427 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3428 pSMB->DataOffset = cpu_to_le16(offset);
3429 pSMB->SetupCount = 1;
3430 pSMB->Reserved3 = 0;
3431 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3432 byte_count = 3 /* pad */ + params + data_count;
3433 pSMB->DataCount = cpu_to_le16(data_count);
3434 pSMB->TotalDataCount = pSMB->DataCount;
3435 pSMB->ParameterCount = cpu_to_le16(params);
3436 pSMB->TotalParameterCount = pSMB->ParameterCount;
3437 pSMB->Reserved4 = 0;
3438 pSMB->hdr.smb_buf_length += byte_count;
3439 parm_data->FileSize = cpu_to_le64(size);
3440 pSMB->ByteCount = cpu_to_le16(byte_count);
3441 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3442 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3443 if (rc) {
3444 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
3445 }
3446
3447 cifs_buf_release(pSMB);
3448
3449 if (rc == -EAGAIN)
3450 goto SetEOFRetry;
3451
3452 return rc;
3453 }
3454
3455 int
3456 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
3457 __u16 fid, __u32 pid_of_opener, int SetAllocation)
3458 {
3459 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3460 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3461 char *data_offset;
3462 struct file_end_of_file_info *parm_data;
3463 int rc = 0;
3464 int bytes_returned = 0;
3465 __u16 params, param_offset, offset, byte_count, count;
3466
3467 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
3468 (long long)size));
3469 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
3470
3471 if (rc)
3472 return rc;
3473
3474 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
3475
3476 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3477 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
3478
3479 params = 6;
3480 pSMB->MaxSetupCount = 0;
3481 pSMB->Reserved = 0;
3482 pSMB->Flags = 0;
3483 pSMB->Timeout = 0;
3484 pSMB->Reserved2 = 0;
3485 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3486 offset = param_offset + params;
3487
3488 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3489
3490 count = sizeof(struct file_end_of_file_info);
3491 pSMB->MaxParameterCount = cpu_to_le16(2);
3492 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3493 pSMB->SetupCount = 1;
3494 pSMB->Reserved3 = 0;
3495 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3496 byte_count = 3 /* pad */ + params + count;
3497 pSMB->DataCount = cpu_to_le16(count);
3498 pSMB->ParameterCount = cpu_to_le16(params);
3499 pSMB->TotalDataCount = pSMB->DataCount;
3500 pSMB->TotalParameterCount = pSMB->ParameterCount;
3501 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3502 parm_data =
3503 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
3504 offset);
3505 pSMB->DataOffset = cpu_to_le16(offset);
3506 parm_data->FileSize = cpu_to_le64(size);
3507 pSMB->Fid = fid;
3508 if(SetAllocation) {
3509 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3510 pSMB->InformationLevel =
3511 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
3512 else
3513 pSMB->InformationLevel =
3514 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
3515 } else /* Set File Size */ {
3516 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3517 pSMB->InformationLevel =
3518 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
3519 else
3520 pSMB->InformationLevel =
3521 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
3522 }
3523 pSMB->Reserved4 = 0;
3524 pSMB->hdr.smb_buf_length += byte_count;
3525 pSMB->ByteCount = cpu_to_le16(byte_count);
3526 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3527 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3528 if (rc) {
3529 cFYI(1,
3530 ("Send error in SetFileInfo (SetFileSize) = %d",
3531 rc));
3532 }
3533
3534 if (pSMB)
3535 cifs_small_buf_release(pSMB);
3536
3537 /* Note: On -EAGAIN error only caller can retry on handle based calls
3538 since file handle passed in no longer valid */
3539
3540 return rc;
3541 }
3542
3543 /* Some legacy servers such as NT4 require that the file times be set on
3544 an open handle, rather than by pathname - this is awkward due to
3545 potential access conflicts on the open, but it is unavoidable for these
3546 old servers since the only other choice is to go from 100 nanosecond DCE
3547 time and resort to the original setpathinfo level which takes the ancient
3548 DOS time format with 2 second granularity */
3549 int
3550 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data,
3551 __u16 fid)
3552 {
3553 struct smb_com_transaction2_sfi_req *pSMB = NULL;
3554 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
3555 char *data_offset;
3556 int rc = 0;
3557 int bytes_returned = 0;
3558 __u16 params, param_offset, offset, byte_count, count;
3559
3560 cFYI(1, ("Set Times (via SetFileInfo)"));
3561 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
3562
3563 if (rc)
3564 return rc;
3565
3566 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
3567
3568 /* At this point there is no need to override the current pid
3569 with the pid of the opener, but that could change if we someday
3570 use an existing handle (rather than opening one on the fly) */
3571 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
3572 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
3573
3574 params = 6;
3575 pSMB->MaxSetupCount = 0;
3576 pSMB->Reserved = 0;
3577 pSMB->Flags = 0;
3578 pSMB->Timeout = 0;
3579 pSMB->Reserved2 = 0;
3580 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
3581 offset = param_offset + params;
3582
3583 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3584
3585 count = sizeof (FILE_BASIC_INFO);
3586 pSMB->MaxParameterCount = cpu_to_le16(2);
3587 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
3588 pSMB->SetupCount = 1;
3589 pSMB->Reserved3 = 0;
3590 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
3591 byte_count = 3 /* pad */ + params + count;
3592 pSMB->DataCount = cpu_to_le16(count);
3593 pSMB->ParameterCount = cpu_to_le16(params);
3594 pSMB->TotalDataCount = pSMB->DataCount;
3595 pSMB->TotalParameterCount = pSMB->ParameterCount;
3596 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3597 pSMB->DataOffset = cpu_to_le16(offset);
3598 pSMB->Fid = fid;
3599 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3600 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3601 else
3602 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3603 pSMB->Reserved4 = 0;
3604 pSMB->hdr.smb_buf_length += byte_count;
3605 pSMB->ByteCount = cpu_to_le16(byte_count);
3606 memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
3607 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3608 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3609 if (rc) {
3610 cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
3611 }
3612
3613 cifs_small_buf_release(pSMB);
3614
3615 /* Note: On -EAGAIN error only caller can retry on handle based calls
3616 since file handle passed in no longer valid */
3617
3618 return rc;
3619 }
3620
3621
3622 int
3623 CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3624 const FILE_BASIC_INFO * data,
3625 const struct nls_table *nls_codepage, int remap)
3626 {
3627 TRANSACTION2_SPI_REQ *pSMB = NULL;
3628 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3629 int name_len;
3630 int rc = 0;
3631 int bytes_returned = 0;
3632 char *data_offset;
3633 __u16 params, param_offset, offset, byte_count, count;
3634
3635 cFYI(1, ("In SetTimes"));
3636
3637 SetTimesRetry:
3638 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3639 (void **) &pSMBr);
3640 if (rc)
3641 return rc;
3642
3643 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3644 name_len =
3645 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
3646 PATH_MAX, nls_codepage, remap);
3647 name_len++; /* trailing null */
3648 name_len *= 2;
3649 } else { /* BB improve the check for buffer overruns BB */
3650 name_len = strnlen(fileName, PATH_MAX);
3651 name_len++; /* trailing null */
3652 strncpy(pSMB->FileName, fileName, name_len);
3653 }
3654
3655 params = 6 + name_len;
3656 count = sizeof (FILE_BASIC_INFO);
3657 pSMB->MaxParameterCount = cpu_to_le16(2);
3658 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3659 pSMB->MaxSetupCount = 0;
3660 pSMB->Reserved = 0;
3661 pSMB->Flags = 0;
3662 pSMB->Timeout = 0;
3663 pSMB->Reserved2 = 0;
3664 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3665 InformationLevel) - 4;
3666 offset = param_offset + params;
3667 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3668 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3669 pSMB->DataOffset = cpu_to_le16(offset);
3670 pSMB->SetupCount = 1;
3671 pSMB->Reserved3 = 0;
3672 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3673 byte_count = 3 /* pad */ + params + count;
3674
3675 pSMB->DataCount = cpu_to_le16(count);
3676 pSMB->ParameterCount = cpu_to_le16(params);
3677 pSMB->TotalDataCount = pSMB->DataCount;
3678 pSMB->TotalParameterCount = pSMB->ParameterCount;
3679 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
3680 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
3681 else
3682 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
3683 pSMB->Reserved4 = 0;
3684 pSMB->hdr.smb_buf_length += byte_count;
3685 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
3686 pSMB->ByteCount = cpu_to_le16(byte_count);
3687 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3688 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3689 if (rc) {
3690 cFYI(1, ("SetPathInfo (times) returned %d", rc));
3691 }
3692
3693 cifs_buf_release(pSMB);
3694
3695 if (rc == -EAGAIN)
3696 goto SetTimesRetry;
3697
3698 return rc;
3699 }
3700
3701 /* Can not be used to set time stamps yet (due to old DOS time format) */
3702 /* Can be used to set attributes */
3703 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
3704 handling it anyway and NT4 was what we thought it would be needed for
3705 Do not delete it until we prove whether needed for Win9x though */
3706 int
3707 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
3708 __u16 dos_attrs, const struct nls_table *nls_codepage)
3709 {
3710 SETATTR_REQ *pSMB = NULL;
3711 SETATTR_RSP *pSMBr = NULL;
3712 int rc = 0;
3713 int bytes_returned;
3714 int name_len;
3715
3716 cFYI(1, ("In SetAttrLegacy"));
3717
3718 SetAttrLgcyRetry:
3719 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
3720 (void **) &pSMBr);
3721 if (rc)
3722 return rc;
3723
3724 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3725 name_len =
3726 ConvertToUCS((__le16 *) pSMB->fileName, fileName,
3727 PATH_MAX, nls_codepage);
3728 name_len++; /* trailing null */
3729 name_len *= 2;
3730 } else { /* BB improve the check for buffer overruns BB */
3731 name_len = strnlen(fileName, PATH_MAX);
3732 name_len++; /* trailing null */
3733 strncpy(pSMB->fileName, fileName, name_len);
3734 }
3735 pSMB->attr = cpu_to_le16(dos_attrs);
3736 pSMB->BufferFormat = 0x04;
3737 pSMB->hdr.smb_buf_length += name_len + 1;
3738 pSMB->ByteCount = cpu_to_le16(name_len + 1);
3739 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3740 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3741 if (rc) {
3742 cFYI(1, ("Error in LegacySetAttr = %d", rc));
3743 }
3744
3745 cifs_buf_release(pSMB);
3746
3747 if (rc == -EAGAIN)
3748 goto SetAttrLgcyRetry;
3749
3750 return rc;
3751 }
3752 #endif /* temporarily unneeded SetAttr legacy function */
3753
3754 int
3755 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
3756 char *fileName, __u64 mode, __u64 uid, __u64 gid,
3757 dev_t device, const struct nls_table *nls_codepage,
3758 int remap)
3759 {
3760 TRANSACTION2_SPI_REQ *pSMB = NULL;
3761 TRANSACTION2_SPI_RSP *pSMBr = NULL;
3762 int name_len;
3763 int rc = 0;
3764 int bytes_returned = 0;
3765 FILE_UNIX_BASIC_INFO *data_offset;
3766 __u16 params, param_offset, offset, count, byte_count;
3767
3768 cFYI(1, ("In SetUID/GID/Mode"));
3769 setPermsRetry:
3770 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3771 (void **) &pSMBr);
3772 if (rc)
3773 return rc;
3774
3775 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3776 name_len =
3777 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
3778 PATH_MAX, nls_codepage, remap);
3779 name_len++; /* trailing null */
3780 name_len *= 2;
3781 } else { /* BB improve the check for buffer overruns BB */
3782 name_len = strnlen(fileName, PATH_MAX);
3783 name_len++; /* trailing null */
3784 strncpy(pSMB->FileName, fileName, name_len);
3785 }
3786
3787 params = 6 + name_len;
3788 count = sizeof (FILE_UNIX_BASIC_INFO);
3789 pSMB->MaxParameterCount = cpu_to_le16(2);
3790 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3791 pSMB->MaxSetupCount = 0;
3792 pSMB->Reserved = 0;
3793 pSMB->Flags = 0;
3794 pSMB->Timeout = 0;
3795 pSMB->Reserved2 = 0;
3796 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3797 InformationLevel) - 4;
3798 offset = param_offset + params;
3799 data_offset =
3800 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
3801 offset);
3802 memset(data_offset, 0, count);
3803 pSMB->DataOffset = cpu_to_le16(offset);
3804 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3805 pSMB->SetupCount = 1;
3806 pSMB->Reserved3 = 0;
3807 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3808 byte_count = 3 /* pad */ + params + count;
3809 pSMB->ParameterCount = cpu_to_le16(params);
3810 pSMB->DataCount = cpu_to_le16(count);
3811 pSMB->TotalParameterCount = pSMB->ParameterCount;
3812 pSMB->TotalDataCount = pSMB->DataCount;
3813 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
3814 pSMB->Reserved4 = 0;
3815 pSMB->hdr.smb_buf_length += byte_count;
3816 data_offset->Uid = cpu_to_le64(uid);
3817 data_offset->Gid = cpu_to_le64(gid);
3818 /* better to leave device as zero when it is */
3819 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
3820 data_offset->DevMinor = cpu_to_le64(MINOR(device));
3821 data_offset->Permissions = cpu_to_le64(mode);
3822
3823 if(S_ISREG(mode))
3824 data_offset->Type = cpu_to_le32(UNIX_FILE);
3825 else if(S_ISDIR(mode))
3826 data_offset->Type = cpu_to_le32(UNIX_DIR);
3827 else if(S_ISLNK(mode))
3828 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
3829 else if(S_ISCHR(mode))
3830 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
3831 else if(S_ISBLK(mode))
3832 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
3833 else if(S_ISFIFO(mode))
3834 data_offset->Type = cpu_to_le32(UNIX_FIFO);
3835 else if(S_ISSOCK(mode))
3836 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
3837
3838
3839 pSMB->ByteCount = cpu_to_le16(byte_count);
3840 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3841 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3842 if (rc) {
3843 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
3844 }
3845
3846 if (pSMB)
3847 cifs_buf_release(pSMB);
3848 if (rc == -EAGAIN)
3849 goto setPermsRetry;
3850 return rc;
3851 }
3852
3853 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
3854 const int notify_subdirs, const __u16 netfid,
3855 __u32 filter, const struct nls_table *nls_codepage)
3856 {
3857 int rc = 0;
3858 struct smb_com_transaction_change_notify_req * pSMB = NULL;
3859 struct smb_com_transaction_change_notify_rsp * pSMBr = NULL;
3860 int bytes_returned;
3861
3862 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
3863 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3864 (void **) &pSMBr);
3865 if (rc)
3866 return rc;
3867
3868 pSMB->TotalParameterCount = 0 ;
3869 pSMB->TotalDataCount = 0;
3870 pSMB->MaxParameterCount = cpu_to_le32(2);
3871 /* BB find exact data count max from sess structure BB */
3872 pSMB->MaxDataCount = 0; /* same in little endian or be */
3873 pSMB->MaxSetupCount = 4;
3874 pSMB->Reserved = 0;
3875 pSMB->ParameterOffset = 0;
3876 pSMB->DataCount = 0;
3877 pSMB->DataOffset = 0;
3878 pSMB->SetupCount = 4; /* single byte does not need le conversion */
3879 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
3880 pSMB->ParameterCount = pSMB->TotalParameterCount;
3881 if(notify_subdirs)
3882 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
3883 pSMB->Reserved2 = 0;
3884 pSMB->CompletionFilter = cpu_to_le32(filter);
3885 pSMB->Fid = netfid; /* file handle always le */
3886 pSMB->ByteCount = 0;
3887
3888 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3889 (struct smb_hdr *) pSMBr, &bytes_returned, -1);
3890 if (rc) {
3891 cFYI(1, ("Error in Notify = %d", rc));
3892 }
3893 cifs_buf_release(pSMB);
3894 return rc;
3895 }
3896 #ifdef CONFIG_CIFS_XATTR
3897 ssize_t
3898 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
3899 const unsigned char *searchName,
3900 char * EAData, size_t buf_size,
3901 const struct nls_table *nls_codepage, int remap)
3902 {
3903 /* BB assumes one setup word */
3904 TRANSACTION2_QPI_REQ *pSMB = NULL;
3905 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3906 int rc = 0;
3907 int bytes_returned;
3908 int name_len;
3909 struct fea * temp_fea;
3910 char * temp_ptr;
3911 __u16 params, byte_count;
3912
3913 cFYI(1, ("In Query All EAs path %s", searchName));
3914 QAllEAsRetry:
3915 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3916 (void **) &pSMBr);
3917 if (rc)
3918 return rc;
3919
3920 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3921 name_len =
3922 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3923 PATH_MAX, nls_codepage, remap);
3924 name_len++; /* trailing null */
3925 name_len *= 2;
3926 } else { /* BB improve the check for buffer overruns BB */
3927 name_len = strnlen(searchName, PATH_MAX);
3928 name_len++; /* trailing null */
3929 strncpy(pSMB->FileName, searchName, name_len);
3930 }
3931
3932 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3933 pSMB->TotalDataCount = 0;
3934 pSMB->MaxParameterCount = cpu_to_le16(2);
3935 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3936 pSMB->MaxSetupCount = 0;
3937 pSMB->Reserved = 0;
3938 pSMB->Flags = 0;
3939 pSMB->Timeout = 0;
3940 pSMB->Reserved2 = 0;
3941 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3942 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3943 pSMB->DataCount = 0;
3944 pSMB->DataOffset = 0;
3945 pSMB->SetupCount = 1;
3946 pSMB->Reserved3 = 0;
3947 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3948 byte_count = params + 1 /* pad */ ;
3949 pSMB->TotalParameterCount = cpu_to_le16(params);
3950 pSMB->ParameterCount = pSMB->TotalParameterCount;
3951 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3952 pSMB->Reserved4 = 0;
3953 pSMB->hdr.smb_buf_length += byte_count;
3954 pSMB->ByteCount = cpu_to_le16(byte_count);
3955
3956 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3957 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3958 if (rc) {
3959 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
3960 } else { /* decode response */
3961 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3962
3963 /* BB also check enough total bytes returned */
3964 /* BB we need to improve the validity checking
3965 of these trans2 responses */
3966 if (rc || (pSMBr->ByteCount < 4))
3967 rc = -EIO; /* bad smb */
3968 /* else if (pFindData){
3969 memcpy((char *) pFindData,
3970 (char *) &pSMBr->hdr.Protocol +
3971 data_offset, kl);
3972 }*/ else {
3973 /* check that length of list is not more than bcc */
3974 /* check that each entry does not go beyond length
3975 of list */
3976 /* check that each element of each entry does not
3977 go beyond end of list */
3978 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3979 struct fealist * ea_response_data;
3980 rc = 0;
3981 /* validate_trans2_offsets() */
3982 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
3983 ea_response_data = (struct fealist *)
3984 (((char *) &pSMBr->hdr.Protocol) +
3985 data_offset);
3986 name_len = le32_to_cpu(ea_response_data->list_len);
3987 cFYI(1,("ea length %d", name_len));
3988 if(name_len <= 8) {
3989 /* returned EA size zeroed at top of function */
3990 cFYI(1,("empty EA list returned from server"));
3991 } else {
3992 /* account for ea list len */
3993 name_len -= 4;
3994 temp_fea = ea_response_data->list;
3995 temp_ptr = (char *)temp_fea;
3996 while(name_len > 0) {
3997 __u16 value_len;
3998 name_len -= 4;
3999 temp_ptr += 4;
4000 rc += temp_fea->name_len;
4001 /* account for prefix user. and trailing null */
4002 rc = rc + 5 + 1;
4003 if(rc<(int)buf_size) {
4004 memcpy(EAData,"user.",5);
4005 EAData+=5;
4006 memcpy(EAData,temp_ptr,temp_fea->name_len);
4007 EAData+=temp_fea->name_len;
4008 /* null terminate name */
4009 *EAData = 0;
4010 EAData = EAData + 1;
4011 } else if(buf_size == 0) {
4012 /* skip copy - calc size only */
4013 } else {
4014 /* stop before overrun buffer */
4015 rc = -ERANGE;
4016 break;
4017 }
4018 name_len -= temp_fea->name_len;
4019 temp_ptr += temp_fea->name_len;
4020 /* account for trailing null */
4021 name_len--;
4022 temp_ptr++;
4023 value_len = le16_to_cpu(temp_fea->value_len);
4024 name_len -= value_len;
4025 temp_ptr += value_len;
4026 /* BB check that temp_ptr is still within smb BB*/
4027 /* no trailing null to account for in value len */
4028 /* go on to next EA */
4029 temp_fea = (struct fea *)temp_ptr;
4030 }
4031 }
4032 }
4033 }
4034 if (pSMB)
4035 cifs_buf_release(pSMB);
4036 if (rc == -EAGAIN)
4037 goto QAllEAsRetry;
4038
4039 return (ssize_t)rc;
4040 }
4041
4042 ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
4043 const unsigned char * searchName,const unsigned char * ea_name,
4044 unsigned char * ea_value, size_t buf_size,
4045 const struct nls_table *nls_codepage, int remap)
4046 {
4047 TRANSACTION2_QPI_REQ *pSMB = NULL;
4048 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4049 int rc = 0;
4050 int bytes_returned;
4051 int name_len;
4052 struct fea * temp_fea;
4053 char * temp_ptr;
4054 __u16 params, byte_count;
4055
4056 cFYI(1, ("In Query EA path %s", searchName));
4057 QEARetry:
4058 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4059 (void **) &pSMBr);
4060 if (rc)
4061 return rc;
4062
4063 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4064 name_len =
4065 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
4066 PATH_MAX, nls_codepage, remap);
4067 name_len++; /* trailing null */
4068 name_len *= 2;
4069 } else { /* BB improve the check for buffer overruns BB */
4070 name_len = strnlen(searchName, PATH_MAX);
4071 name_len++; /* trailing null */
4072 strncpy(pSMB->FileName, searchName, name_len);
4073 }
4074
4075 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4076 pSMB->TotalDataCount = 0;
4077 pSMB->MaxParameterCount = cpu_to_le16(2);
4078 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4079 pSMB->MaxSetupCount = 0;
4080 pSMB->Reserved = 0;
4081 pSMB->Flags = 0;
4082 pSMB->Timeout = 0;
4083 pSMB->Reserved2 = 0;
4084 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4085 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
4086 pSMB->DataCount = 0;
4087 pSMB->DataOffset = 0;
4088 pSMB->SetupCount = 1;
4089 pSMB->Reserved3 = 0;
4090 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4091 byte_count = params + 1 /* pad */ ;
4092 pSMB->TotalParameterCount = cpu_to_le16(params);
4093 pSMB->ParameterCount = pSMB->TotalParameterCount;
4094 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
4095 pSMB->Reserved4 = 0;
4096 pSMB->hdr.smb_buf_length += byte_count;
4097 pSMB->ByteCount = cpu_to_le16(byte_count);
4098
4099 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4100 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4101 if (rc) {
4102 cFYI(1, ("Send error in Query EA = %d", rc));
4103 } else { /* decode response */
4104 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4105
4106 /* BB also check enough total bytes returned */
4107 /* BB we need to improve the validity checking
4108 of these trans2 responses */
4109 if (rc || (pSMBr->ByteCount < 4))
4110 rc = -EIO; /* bad smb */
4111 /* else if (pFindData){
4112 memcpy((char *) pFindData,
4113 (char *) &pSMBr->hdr.Protocol +
4114 data_offset, kl);
4115 }*/ else {
4116 /* check that length of list is not more than bcc */
4117 /* check that each entry does not go beyond length
4118 of list */
4119 /* check that each element of each entry does not
4120 go beyond end of list */
4121 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4122 struct fealist * ea_response_data;
4123 rc = -ENODATA;
4124 /* validate_trans2_offsets() */
4125 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4126 ea_response_data = (struct fealist *)
4127 (((char *) &pSMBr->hdr.Protocol) +
4128 data_offset);
4129 name_len = le32_to_cpu(ea_response_data->list_len);
4130 cFYI(1,("ea length %d", name_len));
4131 if(name_len <= 8) {
4132 /* returned EA size zeroed at top of function */
4133 cFYI(1,("empty EA list returned from server"));
4134 } else {
4135 /* account for ea list len */
4136 name_len -= 4;
4137 temp_fea = ea_response_data->list;
4138 temp_ptr = (char *)temp_fea;
4139 /* loop through checking if we have a matching
4140 name and then return the associated value */
4141 while(name_len > 0) {
4142 __u16 value_len;
4143 name_len -= 4;
4144 temp_ptr += 4;
4145 value_len = le16_to_cpu(temp_fea->value_len);
4146 /* BB validate that value_len falls within SMB,
4147 even though maximum for name_len is 255 */
4148 if(memcmp(temp_fea->name,ea_name,
4149 temp_fea->name_len) == 0) {
4150 /* found a match */
4151 rc = value_len;
4152 /* account for prefix user. and trailing null */
4153 if(rc<=(int)buf_size) {
4154 memcpy(ea_value,
4155 temp_fea->name+temp_fea->name_len+1,
4156 rc);
4157 /* ea values, unlike ea names,
4158 are not null terminated */
4159 } else if(buf_size == 0) {
4160 /* skip copy - calc size only */
4161 } else {
4162 /* stop before overrun buffer */
4163 rc = -ERANGE;
4164 }
4165 break;
4166 }
4167 name_len -= temp_fea->name_len;
4168 temp_ptr += temp_fea->name_len;
4169 /* account for trailing null */
4170 name_len--;
4171 temp_ptr++;
4172 name_len -= value_len;
4173 temp_ptr += value_len;
4174 /* no trailing null to account for in value len */
4175 /* go on to next EA */
4176 temp_fea = (struct fea *)temp_ptr;
4177 }
4178 }
4179 }
4180 }
4181 if (pSMB)
4182 cifs_buf_release(pSMB);
4183 if (rc == -EAGAIN)
4184 goto QEARetry;
4185
4186 return (ssize_t)rc;
4187 }
4188
4189 int
4190 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4191 const char * ea_name, const void * ea_value,
4192 const __u16 ea_value_len, const struct nls_table *nls_codepage,
4193 int remap)
4194 {
4195 struct smb_com_transaction2_spi_req *pSMB = NULL;
4196 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4197 struct fealist *parm_data;
4198 int name_len;
4199 int rc = 0;
4200 int bytes_returned = 0;
4201 __u16 params, param_offset, byte_count, offset, count;
4202
4203 cFYI(1, ("In SetEA"));
4204 SetEARetry:
4205 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4206 (void **) &pSMBr);
4207 if (rc)
4208 return rc;
4209
4210 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4211 name_len =
4212 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4213 PATH_MAX, nls_codepage, remap);
4214 name_len++; /* trailing null */
4215 name_len *= 2;
4216 } else { /* BB improve the check for buffer overruns BB */
4217 name_len = strnlen(fileName, PATH_MAX);
4218 name_len++; /* trailing null */
4219 strncpy(pSMB->FileName, fileName, name_len);
4220 }
4221
4222 params = 6 + name_len;
4223
4224 /* done calculating parms using name_len of file name,
4225 now use name_len to calculate length of ea name
4226 we are going to create in the inode xattrs */
4227 if(ea_name == NULL)
4228 name_len = 0;
4229 else
4230 name_len = strnlen(ea_name,255);
4231
4232 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
4233 pSMB->MaxParameterCount = cpu_to_le16(2);
4234 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
4235 pSMB->MaxSetupCount = 0;
4236 pSMB->Reserved = 0;
4237 pSMB->Flags = 0;
4238 pSMB->Timeout = 0;
4239 pSMB->Reserved2 = 0;
4240 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4241 InformationLevel) - 4;
4242 offset = param_offset + params;
4243 pSMB->InformationLevel =
4244 cpu_to_le16(SMB_SET_FILE_EA);
4245
4246 parm_data =
4247 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
4248 offset);
4249 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4250 pSMB->DataOffset = cpu_to_le16(offset);
4251 pSMB->SetupCount = 1;
4252 pSMB->Reserved3 = 0;
4253 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4254 byte_count = 3 /* pad */ + params + count;
4255 pSMB->DataCount = cpu_to_le16(count);
4256 parm_data->list_len = cpu_to_le32(count);
4257 parm_data->list[0].EA_flags = 0;
4258 /* we checked above that name len is less than 255 */
4259 parm_data->list[0].name_len = (__u8)name_len;;
4260 /* EA names are always ASCII */
4261 if(ea_name)
4262 strncpy(parm_data->list[0].name,ea_name,name_len);
4263 parm_data->list[0].name[name_len] = 0;
4264 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
4265 /* caller ensures that ea_value_len is less than 64K but
4266 we need to ensure that it fits within the smb */
4267
4268 /*BB add length check that it would fit in negotiated SMB buffer size BB */
4269 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
4270 if(ea_value_len)
4271 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
4272
4273 pSMB->TotalDataCount = pSMB->DataCount;
4274 pSMB->ParameterCount = cpu_to_le16(params);
4275 pSMB->TotalParameterCount = pSMB->ParameterCount;
4276 pSMB->Reserved4 = 0;
4277 pSMB->hdr.smb_buf_length += byte_count;
4278 pSMB->ByteCount = cpu_to_le16(byte_count);
4279 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4280 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4281 if (rc) {
4282 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
4283 }
4284
4285 cifs_buf_release(pSMB);
4286
4287 if (rc == -EAGAIN)
4288 goto SetEARetry;
4289
4290 return rc;
4291 }
4292
4293 #endif
Verdex Pro support