?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.9
[linux-2.6.9-moxart.git] / fs / cifs / cifssmb.c
blob8e17185383f02151a33de605dcc835ef0eb09b36
1 /*
2 * fs/cifs/cifssmb.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2003
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 <asm/uaccess.h>
34 #include "cifspdu.h"
35 #include "cifsglob.h"
36 #include "cifsproto.h"
37 #include "cifs_unicode.h"
38 #include "cifs_debug.h"
39
40 #ifdef CONFIG_CIFS_POSIX
41 static struct {
42 int index;
43 char *name;
44 } protocols[] = {
45 {CIFS_PROT, "\2NT LM 0.12"},
46 {CIFS_PROT, "\2POSIX 2"},
47 {BAD_PROT, "\2"}
48 };
49 #else
50 static struct {
51 int index;
52 char *name;
53 } protocols[] = {
54 {CIFS_PROT, "\2NT LM 0.12"},
55 {BAD_PROT, "\2"}
56 };
57 #endif
58
59
60 /* Mark as invalid, all open files on tree connections since they
61 were closed when session to server was lost */
62 static void mark_open_files_invalid(struct cifsTconInfo * pTcon)
63 {
64 struct cifsFileInfo *open_file = NULL;
65 struct list_head * tmp;
66 struct list_head * tmp1;
67
68 /* list all files open on tree connection and mark them invalid */
69 write_lock(&GlobalSMBSeslock);
70 list_for_each_safe(tmp, tmp1, &pTcon->openFileList) {
71 open_file = list_entry(tmp,struct cifsFileInfo, tlist);
72 if(open_file) {
73 open_file->invalidHandle = TRUE;
74 }
75 }
76 write_unlock(&GlobalSMBSeslock);
77 /* BB Add call to invalidate_inodes(sb) for all superblocks mounted to this tcon */
78 }
79
80 static int
81 smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
82 void **request_buf /* returned */ ,
83 void **response_buf /* returned */ )
84 {
85 int rc = 0;
86
87 /* SMBs NegProt, SessSetup, uLogoff do not have tcon yet so
88 check for tcp and smb session status done differently
89 for those three - in the calling routine */
90 if(tcon) {
91 if((tcon->ses) && (tcon->ses->server)){
92 struct nls_table *nls_codepage;
93 /* Give Demultiplex thread up to 10 seconds to
94 reconnect, should be greater than cifs socket
95 timeout which is 7 seconds */
96 while(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
97 wait_event_interruptible_timeout(tcon->ses->server->response_q,
98 (tcon->ses->server->tcpStatus == CifsGood), 10 * HZ);
99 if(tcon->ses->server->tcpStatus == CifsNeedReconnect) {
100 /* on "soft" mounts we wait once */
101 if((tcon->retry == FALSE) ||
102 (tcon->ses->status == CifsExiting)) {
103 cFYI(1,("gave up waiting on reconnect in smb_init"));
104 return -EHOSTDOWN;
105 } /* else "hard" mount - keep retrying until
106 process is killed or server comes back up */
107 } else /* TCP session is reestablished now */
108 break;
109
110 }
111
112 nls_codepage = load_nls_default();
113 /* need to prevent multiple threads trying to
114 simultaneously reconnect the same SMB session */
115 down(&tcon->ses->sesSem);
116 if(tcon->ses->status == CifsNeedReconnect)
117 rc = cifs_setup_session(0, tcon->ses, nls_codepage);
118 if(!rc && (tcon->tidStatus == CifsNeedReconnect)) {
119 mark_open_files_invalid(tcon);
120 rc = CIFSTCon(0, tcon->ses, tcon->treeName, tcon,
121 nls_codepage);
122 up(&tcon->ses->sesSem);
123 if(rc == 0)
124 atomic_inc(&tconInfoReconnectCount);
125
126 cFYI(1, ("reconnect tcon rc = %d", rc));
127 /* Removed call to reopen open files here -
128 it is safer (and faster) to reopen files
129 one at a time as needed in read and write */
130
131 /* Check if handle based operation so we
132 know whether we can continue or not without
133 returning to caller to reset file handle */
134 switch(smb_command) {
135 case SMB_COM_READ_ANDX:
136 case SMB_COM_WRITE_ANDX:
137 case SMB_COM_CLOSE:
138 case SMB_COM_FIND_CLOSE2:
139 case SMB_COM_LOCKING_ANDX: {
140 unload_nls(nls_codepage);
141 return -EAGAIN;
142 }
143 }
144 } else {
145 up(&tcon->ses->sesSem);
146 }
147 unload_nls(nls_codepage);
148
149 } else {
150 return -EIO;
151 }
152 }
153 if(rc)
154 return rc;
155
156 *request_buf = cifs_buf_get();
157 if (*request_buf == 0) {
158 /* BB should we add a retry in here if not a writepage? */
159 return -ENOMEM;
160 }
161 /* Although the original thought was we needed the response buf for */
162 /* potential retries of smb operations it turns out we can determine */
163 /* from the mid flags when the request buffer can be resent without */
164 /* having to use a second distinct buffer for the response */
165 *response_buf = *request_buf;
166
167 header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
168 wct /*wct */ );
169
170 #ifdef CONFIG_CIFS_STATS
171 if(tcon != NULL) {
172 atomic_inc(&tcon->num_smbs_sent);
173 }
174 #endif
175 return rc;
176 }
177
178 int
179 CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
180 {
181 NEGOTIATE_REQ *pSMB;
182 NEGOTIATE_RSP *pSMBr;
183 int rc = 0;
184 int bytes_returned;
185 struct TCP_Server_Info * server;
186 u16 count;
187
188 if(ses->server)
189 server = ses->server;
190 else {
191 rc = -EIO;
192 return rc;
193 }
194 rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
195 (void **) &pSMB, (void **) &pSMBr);
196 if (rc)
197 return rc;
198
199 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
200 if (extended_security)
201 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
202
203 count = strlen(protocols[0].name) + 1;
204 strncpy(pSMB->DialectsArray, protocols[0].name, 30);
205 /* null guaranteed to be at end of source and target buffers anyway */
206
207 pSMB->hdr.smb_buf_length += count;
208 pSMB->ByteCount = cpu_to_le16(count);
209
210 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
211 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
212 if (rc == 0) {
213 server->secMode = pSMBr->SecurityMode;
214 server->secType = NTLM; /* BB override default for NTLMv2 or krb*/
215 /* one byte - no need to convert this or EncryptionKeyLen from le,*/
216 server->maxReq = le16_to_cpu(pSMBr->MaxMpxCount);
217 /* probably no need to store and check maxvcs */
218 server->maxBuf =
219 min(le32_to_cpu(pSMBr->MaxBufferSize),
220 (__u32) CIFS_MAX_MSGSIZE + MAX_CIFS_HDR_SIZE);
221 server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
222 cFYI(0, ("Max buf = %d ", ses->server->maxBuf));
223 GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
224 server->capabilities = le32_to_cpu(pSMBr->Capabilities);
225 server->timeZone = le16_to_cpu(pSMBr->ServerTimeZone);
226 /* BB with UTC do we ever need to be using srvr timezone? */
227 if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
228 memcpy(server->cryptKey, pSMBr->u.EncryptionKey,
229 CIFS_CRYPTO_KEY_SIZE);
230 } else if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC)
231 && (pSMBr->EncryptionKeyLength == 0)) {
232 /* decode security blob */
233 } else
234 rc = -EIO;
235
236 /* BB might be helpful to save off the domain of server here */
237
238 if ((pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC) &&
239 (server->capabilities & CAP_EXTENDED_SECURITY)) {
240 count = pSMBr->ByteCount;
241 if (count < 16)
242 rc = -EIO;
243 else if (count == 16) {
244 server->secType = RawNTLMSSP;
245 if (server->socketUseCount.counter > 1) {
246 if (memcmp
247 (server->server_GUID,
248 pSMBr->u.extended_response.
249 GUID, 16) != 0) {
250 cFYI(1,
251 ("UID of server does not match previous connection to same ip address"));
252 memcpy(server->
253 server_GUID,
254 pSMBr->u.
255 extended_response.
256 GUID, 16);
257 }
258 } else
259 memcpy(server->server_GUID,
260 pSMBr->u.extended_response.
261 GUID, 16);
262 } else {
263 rc = decode_negTokenInit(pSMBr->u.
264 extended_response.
265 SecurityBlob,
266 count - 16,
267 &server->secType);
268 }
269 } else
270 server->capabilities &= ~CAP_EXTENDED_SECURITY;
271 if(sign_CIFS_PDUs == FALSE) {
272 if(server->secMode & SECMODE_SIGN_REQUIRED)
273 cERROR(1,
274 ("Server requires /proc/fs/cifs/PacketSigningEnabled"));
275 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
276 } else if(sign_CIFS_PDUs == 1) {
277 if((server->secMode & SECMODE_SIGN_REQUIRED) == 0)
278 server->secMode &= ~(SECMODE_SIGN_ENABLED | SECMODE_SIGN_REQUIRED);
279 }
280
281 }
282 if (pSMB)
283 cifs_buf_release(pSMB);
284 return rc;
285 }
286
287 int
288 CIFSSMBTDis(const int xid, struct cifsTconInfo *tcon)
289 {
290 struct smb_hdr *smb_buffer;
291 struct smb_hdr *smb_buffer_response;
292 int rc = 0;
293 int length;
294
295 cFYI(1, ("In tree disconnect"));
296 /*
297 * If last user of the connection and
298 * connection alive - disconnect it
299 * If this is the last connection on the server session disconnect it
300 * (and inside session disconnect we should check if tcp socket needs
301 * to be freed and kernel thread woken up).
302 */
303 if (tcon)
304 down(&tcon->tconSem);
305 else
306 return -EIO;
307
308 atomic_dec(&tcon->useCount);
309 if (atomic_read(&tcon->useCount) > 0) {
310 up(&tcon->tconSem);
311 return -EBUSY;
312 }
313
314 /* No need to return error on this operation if tid invalidated and
315 closed on server already e.g. due to tcp session crashing */
316 if(tcon->tidStatus == CifsNeedReconnect) {
317 up(&tcon->tconSem);
318 return 0;
319 }
320
321 if((tcon->ses == 0) || (tcon->ses->server == 0)) {
322 up(&tcon->tconSem);
323 return -EIO;
324 }
325
326 rc = smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
327 (void **) &smb_buffer, (void **) &smb_buffer_response);
328 if (rc) {
329 up(&tcon->tconSem);
330 return rc;
331 }
332 rc = SendReceive(xid, tcon->ses, smb_buffer, smb_buffer_response,
333 &length, 0);
334 if (rc)
335 cFYI(1, (" Tree disconnect failed %d", rc));
336
337 if (smb_buffer)
338 cifs_buf_release(smb_buffer);
339 up(&tcon->tconSem);
340
341 /* No need to return error on this operation if tid invalidated and
342 closed on server already e.g. due to tcp session crashing */
343 if (rc == -EAGAIN)
344 rc = 0;
345
346 return rc;
347 }
348
349 int
350 CIFSSMBLogoff(const int xid, struct cifsSesInfo *ses)
351 {
352 struct smb_hdr *smb_buffer_response;
353 LOGOFF_ANDX_REQ *pSMB;
354 int rc = 0;
355 int length;
356
357 cFYI(1, ("In SMBLogoff for session disconnect"));
358 if (ses)
359 down(&ses->sesSem);
360 else
361 return -EIO;
362
363 atomic_dec(&ses->inUse);
364 if (atomic_read(&ses->inUse) > 0) {
365 up(&ses->sesSem);
366 return -EBUSY;
367 }
368
369 rc = smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL /* no tcon anymore */,
370 (void **) &pSMB, (void **) &smb_buffer_response);
371
372 if(ses->server) {
373 if(ses->server->secMode &
374 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
375 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
376 }
377
378 if (rc) {
379 up(&ses->sesSem);
380 return rc;
381 }
382
383 pSMB->hdr.Uid = ses->Suid;
384
385 pSMB->AndXCommand = 0xFF;
386 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
387 smb_buffer_response, &length, 0);
388 if (ses->server) {
389 atomic_dec(&ses->server->socketUseCount);
390 if (atomic_read(&ses->server->socketUseCount) == 0) {
391 spin_lock(&GlobalMid_Lock);
392 ses->server->tcpStatus = CifsExiting;
393 spin_unlock(&GlobalMid_Lock);
394 rc = -ESHUTDOWN;
395 }
396 }
397 if (pSMB)
398 cifs_buf_release(pSMB);
399 up(&ses->sesSem);
400
401 /* if session dead then we do not need to do ulogoff,
402 since server closed smb session, no sense reporting
403 error */
404 if (rc == -EAGAIN)
405 rc = 0;
406 return rc;
407 }
408
409 int
410 CIFSSMBDelFile(const int xid, struct cifsTconInfo *tcon,
411 const char *fileName, const struct nls_table *nls_codepage)
412 {
413 DELETE_FILE_REQ *pSMB = NULL;
414 DELETE_FILE_RSP *pSMBr = NULL;
415 int rc = 0;
416 int bytes_returned;
417 int name_len;
418
419 DelFileRetry:
420 rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
421 (void **) &pSMBr);
422 if (rc)
423 return rc;
424
425 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
426 name_len =
427 cifs_strtoUCS((wchar_t *) pSMB->fileName, fileName, 530
428 /* find define for this maxpathcomponent */
429 , nls_codepage);
430 name_len++; /* trailing null */
431 name_len *= 2;
432 } else { /* BB improve the check for buffer overruns BB */
433 name_len = strnlen(fileName, 530);
434 name_len++; /* trailing null */
435 strncpy(pSMB->fileName, fileName, name_len);
436 }
437 pSMB->SearchAttributes =
438 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
439 pSMB->BufferFormat = 0x04;
440 pSMB->hdr.smb_buf_length += name_len + 1;
441 pSMB->ByteCount = cpu_to_le16(name_len + 1);
442 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
443 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
444 if (rc) {
445 cFYI(1, ("Error in RMFile = %d", rc));
446 }
447 #ifdef CONFIG_CIFS_STATS
448 else {
449 atomic_inc(&tcon->num_deletes);
450 }
451 #endif
452
453 if (pSMB)
454 cifs_buf_release(pSMB);
455 if (rc == -EAGAIN)
456 goto DelFileRetry;
457
458 return rc;
459 }
460
461 int
462 CIFSSMBRmDir(const int xid, struct cifsTconInfo *tcon,
463 const char *dirName, const struct nls_table *nls_codepage)
464 {
465 DELETE_DIRECTORY_REQ *pSMB = NULL;
466 DELETE_DIRECTORY_RSP *pSMBr = NULL;
467 int rc = 0;
468 int bytes_returned;
469 int name_len;
470
471 cFYI(1, ("In CIFSSMBRmDir"));
472 RmDirRetry:
473 rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
474 (void **) &pSMBr);
475 if (rc)
476 return rc;
477
478 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
479 name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, dirName, 530
480 /* find define for this maxpathcomponent */
481 , nls_codepage);
482 name_len++; /* trailing null */
483 name_len *= 2;
484 } else { /* BB improve the check for buffer overruns BB */
485 name_len = strnlen(dirName, 530);
486 name_len++; /* trailing null */
487 strncpy(pSMB->DirName, dirName, name_len);
488 }
489
490 pSMB->BufferFormat = 0x04;
491 pSMB->hdr.smb_buf_length += name_len + 1;
492 pSMB->ByteCount = cpu_to_le16(name_len + 1);
493 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
494 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
495 if (rc) {
496 cFYI(1, ("Error in RMDir = %d", rc));
497 }
498 #ifdef CONFIG_CIFS_STATS
499 else {
500 atomic_inc(&tcon->num_rmdirs);
501 }
502 #endif
503
504 if (pSMB)
505 cifs_buf_release(pSMB);
506 if (rc == -EAGAIN)
507 goto RmDirRetry;
508 return rc;
509 }
510
511 int
512 CIFSSMBMkDir(const int xid, struct cifsTconInfo *tcon,
513 const char *name, const struct nls_table *nls_codepage)
514 {
515 int rc = 0;
516 CREATE_DIRECTORY_REQ *pSMB = NULL;
517 CREATE_DIRECTORY_RSP *pSMBr = NULL;
518 int bytes_returned;
519 int name_len;
520
521 cFYI(1, ("In CIFSSMBMkDir"));
522 MkDirRetry:
523 rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
524 (void **) &pSMBr);
525 if (rc)
526 return rc;
527
528 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
529 name_len = cifs_strtoUCS((wchar_t *) pSMB->DirName, name, 530
530 /* find define for this maxpathcomponent */
531 , nls_codepage);
532 name_len++; /* trailing null */
533 name_len *= 2;
534 } else { /* BB improve the check for buffer overruns BB */
535 name_len = strnlen(name, 530);
536 name_len++; /* trailing null */
537 strncpy(pSMB->DirName, name, name_len);
538 }
539
540 pSMB->BufferFormat = 0x04;
541 pSMB->hdr.smb_buf_length += name_len + 1;
542 pSMB->ByteCount = cpu_to_le16(name_len + 1);
543 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
544 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
545 if (rc) {
546 cFYI(1, ("Error in Mkdir = %d", rc));
547 }
548 #ifdef CONFIG_CIFS_STATS
549 else {
550 atomic_inc(&tcon->num_mkdirs);
551 }
552 #endif
553 if (pSMB)
554 cifs_buf_release(pSMB);
555 if (rc == -EAGAIN)
556 goto MkDirRetry;
557 return rc;
558 }
559
560 int
561 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
562 const char *fileName, const int openDisposition,
563 const int access_flags, const int create_options, __u16 * netfid,
564 int *pOplock, FILE_ALL_INFO * pfile_info,
565 const struct nls_table *nls_codepage)
566 {
567 int rc = -EACCES;
568 OPEN_REQ *pSMB = NULL;
569 OPEN_RSP *pSMBr = NULL;
570 int bytes_returned;
571 int name_len;
572 __u16 count;
573
574 openRetry:
575 rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
576 (void **) &pSMBr);
577 if (rc)
578 return rc;
579
580 pSMB->AndXCommand = 0xFF; /* none */
581
582 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
583 count = 1; /* account for one byte pad to word boundary */
584 name_len =
585 cifs_strtoUCS((wchar_t *) (pSMB->fileName + 1),
586 fileName, 530
587 /* find define for this maxpathcomponent */
588 , nls_codepage);
589 name_len++; /* trailing null */
590 name_len *= 2;
591 pSMB->NameLength = cpu_to_le16(name_len);
592 } else { /* BB improve the check for buffer overruns BB */
593 count = 0; /* no pad */
594 name_len = strnlen(fileName, 530);
595 name_len++; /* trailing null */
596 pSMB->NameLength = cpu_to_le16(name_len);
597 strncpy(pSMB->fileName, fileName, name_len);
598 }
599 if (*pOplock & REQ_OPLOCK)
600 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
601 else if (*pOplock & REQ_BATCHOPLOCK) {
602 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
603 }
604 pSMB->DesiredAccess = cpu_to_le32(access_flags);
605 pSMB->AllocationSize = 0;
606 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
607 /* XP does not handle ATTR_POSIX_SEMANTICS */
608 /* but it helps speed up case sensitive checks for other
609 servers such as Samba */
610 if (tcon->ses->capabilities & CAP_UNIX)
611 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
612
613 /* if ((omode & S_IWUGO) == 0)
614 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
615 /* Above line causes problems due to vfs splitting create into two
616 pieces - need to set mode after file created not while it is
617 being created */
618 pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
619 pSMB->CreateDisposition = cpu_to_le32(openDisposition);
620 pSMB->CreateOptions = cpu_to_le32(create_options);
621 pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION); /* BB ??*/
622 pSMB->SecurityFlags =
623 SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
624
625 count += name_len;
626 pSMB->hdr.smb_buf_length += count;
627
628 pSMB->ByteCount = cpu_to_le16(count);
629 /* long_op set to 1 to allow for oplock break timeouts */
630 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
631 (struct smb_hdr *) pSMBr, &bytes_returned, 1);
632 if (rc) {
633 cFYI(1, ("Error in Open = %d", rc));
634 } else {
635 *pOplock = pSMBr->OplockLevel; /* one byte no need to le_to_cpu */
636 *netfid = pSMBr->Fid; /* cifs fid stays in le */
637 /* Let caller know file was created so we can set the mode. */
638 /* Do we care about the CreateAction in any other cases? */
639 if(cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
640 *pOplock |= CIFS_CREATE_ACTION;
641 if(pfile_info) {
642 memcpy((char *)pfile_info,(char *)&pSMBr->CreationTime,
643 36 /* CreationTime to Attributes */);
644 /* the file_info buf is endian converted by caller */
645 pfile_info->AllocationSize = pSMBr->AllocationSize;
646 pfile_info->EndOfFile = pSMBr->EndOfFile;
647 pfile_info->NumberOfLinks = cpu_to_le32(1);
648 }
649
650 #ifdef CONFIG_CIFS_STATS
651 atomic_inc(&tcon->num_opens);
652 #endif
653 }
654 if (pSMB)
655 cifs_buf_release(pSMB);
656 if (rc == -EAGAIN)
657 goto openRetry;
658 return rc;
659 }
660
661 /* If no buffer passed in, then caller wants to do the copy
662 as in the case of readpages so the SMB buffer must be
663 freed by the caller */
664
665 int
666 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
667 const int netfid, const unsigned int count,
668 const __u64 lseek, unsigned int *nbytes, char **buf)
669 {
670 int rc = -EACCES;
671 READ_REQ *pSMB = NULL;
672 READ_RSP *pSMBr = NULL;
673 char *pReadData = NULL;
674 int bytes_returned;
675
676 *nbytes = 0;
677 rc = smb_init(SMB_COM_READ_ANDX, 12, tcon, (void **) &pSMB,
678 (void **) &pSMBr);
679 if (rc)
680 return rc;
681
682 /* tcon and ses pointer are checked in smb_init */
683 if (tcon->ses->server == NULL)
684 return -ECONNABORTED;
685
686 pSMB->AndXCommand = 0xFF; /* none */
687 pSMB->Fid = netfid;
688 pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
689 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
690 pSMB->Remaining = 0;
691 pSMB->MaxCount = cpu_to_le16(count);
692 pSMB->MaxCountHigh = 0;
693 pSMB->ByteCount = 0; /* no need to do le conversion since it is 0 */
694
695 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
696 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
697 if (rc) {
698 cERROR(1, ("Send error in read = %d", rc));
699 } else {
700 __u16 data_length = le16_to_cpu(pSMBr->DataLength);
701 *nbytes = data_length;
702 /*check that DataLength would not go beyond end of SMB */
703 if ((data_length > CIFS_MAX_MSGSIZE)
704 || (data_length > count)) {
705 cFYI(1,("bad length %d for count %d",data_length,count));
706 rc = -EIO;
707 *nbytes = 0;
708 } else {
709 pReadData =
710 (char *) (&pSMBr->hdr.Protocol) +
711 le16_to_cpu(pSMBr->DataOffset);
712 /* if(rc = copy_to_user(buf, pReadData, data_length)) {
713 cERROR(1,("Faulting on read rc = %d",rc));
714 rc = -EFAULT;
715 }*/ /* can not use copy_to_user when using page cache*/
716 if(*buf)
717 memcpy(*buf,pReadData,data_length);
718 }
719 }
720 if (pSMB) {
721 if(*buf)
722 cifs_buf_release(pSMB);
723 else
724 *buf = (char *)pSMB;
725 }
726
727 /* Note: On -EAGAIN error only caller can retry on handle based calls
728 since file handle passed in no longer valid */
729 return rc;
730 }
731
732 int
733 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
734 const int netfid, const unsigned int count,
735 const __u64 offset, unsigned int *nbytes, const char *buf,
736 const int long_op)
737 {
738 int rc = -EACCES;
739 WRITE_REQ *pSMB = NULL;
740 WRITE_RSP *pSMBr = NULL;
741 int bytes_returned;
742 unsigned bytes_sent;
743 __u16 byte_count;
744
745 rc = smb_init(SMB_COM_WRITE_ANDX, 14, tcon, (void **) &pSMB,
746 (void **) &pSMBr);
747 if (rc)
748 return rc;
749 /* tcon and ses pointer are checked in smb_init */
750 if (tcon->ses->server == NULL)
751 return -ECONNABORTED;
752
753 pSMB->AndXCommand = 0xFF; /* none */
754 pSMB->Fid = netfid;
755 pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
756 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
757 pSMB->Remaining = 0;
758 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & ~0xFF;
759 if (bytes_sent > count)
760 bytes_sent = count;
761 pSMB->DataLengthHigh = 0;
762 pSMB->DataOffset =
763 cpu_to_le16(offsetof(struct smb_com_write_req,Data) - 4);
764
765 memcpy(pSMB->Data,buf,bytes_sent);
766
767 byte_count = bytes_sent + 1 /* pad */ ;
768 pSMB->DataLengthLow = cpu_to_le16(bytes_sent);
769 pSMB->DataLengthHigh = 0;
770 pSMB->hdr.smb_buf_length += byte_count;
771 pSMB->ByteCount = cpu_to_le16(byte_count);
772
773 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
774 (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
775 if (rc) {
776 cFYI(1, ("Send error in write = %d", rc));
777 *nbytes = 0;
778 } else
779 *nbytes = le16_to_cpu(pSMBr->Count);
780
781 if (pSMB)
782 cifs_buf_release(pSMB);
783
784 /* Note: On -EAGAIN error only caller can retry on handle based calls
785 since file handle passed in no longer valid */
786
787 return rc;
788 }
789
790 int
791 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
792 const __u16 smb_file_id, const __u64 len,
793 const __u64 offset, const __u32 numUnlock,
794 const __u32 numLock, const __u8 lockType, const int waitFlag)
795 {
796 int rc = 0;
797 LOCK_REQ *pSMB = NULL;
798 LOCK_RSP *pSMBr = NULL;
799 int bytes_returned;
800 int timeout = 0;
801 __u16 count;
802
803 cFYI(1, ("In CIFSSMBLock - timeout %d numLock %d",waitFlag,numLock));
804 rc = smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB,
805 (void **) &pSMBr);
806 if (rc)
807 return rc;
808
809 if(lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
810 timeout = -1; /* no response expected */
811 pSMB->Timeout = 0;
812 } else if (waitFlag == TRUE) {
813 timeout = 3; /* blocking operation, no timeout */
814 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
815 } else {
816 pSMB->Timeout = 0;
817 }
818
819 pSMB->NumberOfLocks = cpu_to_le16(numLock);
820 pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
821 pSMB->LockType = lockType;
822 pSMB->AndXCommand = 0xFF; /* none */
823 pSMB->Fid = smb_file_id; /* netfid stays le */
824
825 if((numLock != 0) || (numUnlock != 0)) {
826 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
827 /* BB where to store pid high? */
828 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
829 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
830 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
831 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
832 count = sizeof(LOCKING_ANDX_RANGE);
833 } else {
834 /* oplock break */
835 count = 0;
836 }
837 pSMB->hdr.smb_buf_length += count;
838 pSMB->ByteCount = cpu_to_le16(count);
839
840 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
841 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
842
843 if (rc) {
844 cFYI(1, ("Send error in Lock = %d", rc));
845 }
846 if (pSMB)
847 cifs_buf_release(pSMB);
848
849 /* Note: On -EAGAIN error only caller can retry on handle based calls
850 since file handle passed in no longer valid */
851 return rc;
852 }
853
854 int
855 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
856 {
857 int rc = 0;
858 CLOSE_REQ *pSMB = NULL;
859 CLOSE_RSP *pSMBr = NULL;
860 int bytes_returned;
861 cFYI(1, ("In CIFSSMBClose"));
862
863 /* do not retry on dead session on close */
864 rc = smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB,
865 (void **) &pSMBr);
866 if(rc == -EAGAIN)
867 return 0;
868 if (rc)
869 return rc;
870
871 pSMB->FileID = (__u16) smb_file_id;
872 pSMB->LastWriteTime = 0;
873 pSMB->ByteCount = 0;
874 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
875 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
876 if (rc) {
877 if(rc!=-EINTR) {
878 /* EINTR is expected when user ctl-c to kill app */
879 cERROR(1, ("Send error in Close = %d", rc));
880 }
881 }
882 if (pSMB)
883 cifs_buf_release(pSMB);
884
885 /* Since session is dead, file will be closed on server already */
886 if(rc == -EAGAIN)
887 rc = 0;
888
889 return rc;
890 }
891
892 int
893 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
894 const char *fromName, const char *toName,
895 const struct nls_table *nls_codepage)
896 {
897 int rc = 0;
898 RENAME_REQ *pSMB = NULL;
899 RENAME_RSP *pSMBr = NULL;
900 int bytes_returned;
901 int name_len, name_len2;
902 __u16 count;
903
904 cFYI(1, ("In CIFSSMBRename"));
905 renameRetry:
906 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
907 (void **) &pSMBr);
908 if (rc)
909 return rc;
910
911 pSMB->BufferFormat = 0x04;
912 pSMB->SearchAttributes =
913 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
914 ATTR_DIRECTORY);
915
916 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
917 name_len =
918 cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, 530
919 /* find define for this maxpathcomponent */
920 , nls_codepage);
921 name_len++; /* trailing null */
922 name_len *= 2;
923 pSMB->OldFileName[name_len] = 0x04; /* pad */
924 /* protocol requires ASCII signature byte on Unicode string */
925 pSMB->OldFileName[name_len + 1] = 0x00;
926 name_len2 =
927 cifs_strtoUCS((wchar_t *) & pSMB->
928 OldFileName[name_len + 2], toName, 530,
929 nls_codepage);
930 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
931 name_len2 *= 2; /* convert to bytes */
932 } else { /* BB improve the check for buffer overruns BB */
933 name_len = strnlen(fromName, 530);
934 name_len++; /* trailing null */
935 strncpy(pSMB->OldFileName, fromName, name_len);
936 name_len2 = strnlen(toName, 530);
937 name_len2++; /* trailing null */
938 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
939 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
940 name_len2++; /* trailing null */
941 name_len2++; /* signature byte */
942 }
943
944 count = 1 /* 1st signature byte */ + name_len + name_len2;
945 pSMB->hdr.smb_buf_length += count;
946 pSMB->ByteCount = cpu_to_le16(count);
947
948 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
949 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
950 if (rc) {
951 cFYI(1, ("Send error in rename = %d", rc));
952 }
953
954 #ifdef CONFIG_CIFS_STATS
955 else {
956 atomic_inc(&tcon->num_renames);
957 }
958 #endif
959
960 if (pSMB)
961 cifs_buf_release(pSMB);
962
963 if (rc == -EAGAIN)
964 goto renameRetry;
965
966 return rc;
967 }
968
969 int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
970 int netfid, char * target_name, const struct nls_table * nls_codepage)
971 {
972 struct smb_com_transaction2_sfi_req *pSMB = NULL;
973 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
974 struct set_file_rename * rename_info;
975 char *data_offset;
976 char dummy_string[30];
977 int rc = 0;
978 int bytes_returned = 0;
979 int len_of_str;
980 __u16 params, param_offset, offset, count, byte_count;
981
982 cFYI(1, ("Rename to File by handle"));
983 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
984 (void **) &pSMBr);
985 if (rc)
986 return rc;
987
988 params = 6;
989 pSMB->MaxSetupCount = 0;
990 pSMB->Reserved = 0;
991 pSMB->Flags = 0;
992 pSMB->Timeout = 0;
993 pSMB->Reserved2 = 0;
994 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
995 offset = param_offset + params;
996
997 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
998 rename_info = (struct set_file_rename *) data_offset;
999 pSMB->MaxParameterCount = cpu_to_le16(2);
1000 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1001 pSMB->SetupCount = 1;
1002 pSMB->Reserved3 = 0;
1003 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1004 byte_count = 3 /* pad */ + params;
1005 pSMB->ParameterCount = cpu_to_le16(params);
1006 pSMB->TotalParameterCount = pSMB->ParameterCount;
1007 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1008 pSMB->DataOffset = cpu_to_le16(offset);
1009 /* construct random name ".cifs_tmp<inodenum><mid>" */
1010 rename_info->overwrite = cpu_to_le32(1);
1011 rename_info->root_fid = 0;
1012 /* unicode only call */
1013 if(target_name == NULL) {
1014 sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
1015 len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, dummy_string, 24, nls_codepage);
1016 } else {
1017 len_of_str = cifs_strtoUCS((wchar_t *) rename_info->target_name, target_name, 530, nls_codepage);
1018 }
1019 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
1020 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
1021 byte_count += count;
1022 pSMB->DataCount = cpu_to_le16(count);
1023 pSMB->TotalDataCount = pSMB->DataCount;
1024 pSMB->Fid = netfid;
1025 pSMB->InformationLevel =
1026 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
1027 pSMB->Reserved4 = 0;
1028 pSMB->hdr.smb_buf_length += byte_count;
1029 pSMB->ByteCount = cpu_to_le16(byte_count);
1030 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
1031 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1032 if (rc) {
1033 cFYI(1,("Send error in Rename (by file handle) = %d", rc));
1034 }
1035 #ifdef CONFIG_CIFS_STATS
1036 else {
1037 atomic_inc(&pTcon->num_t2renames);
1038 }
1039 #endif
1040 if (pSMB)
1041 cifs_buf_release(pSMB);
1042
1043 /* Note: On -EAGAIN error only caller can retry on handle based calls
1044 since file handle passed in no longer valid */
1045
1046 return rc;
1047 }
1048
1049 int
1050 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName,
1051 const __u16 target_tid, const char *toName, const int flags,
1052 const struct nls_table *nls_codepage)
1053 {
1054 int rc = 0;
1055 COPY_REQ *pSMB = NULL;
1056 COPY_RSP *pSMBr = NULL;
1057 int bytes_returned;
1058 int name_len, name_len2;
1059 __u16 count;
1060
1061 cFYI(1, ("In CIFSSMBCopy"));
1062 copyRetry:
1063 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
1064 (void **) &pSMBr);
1065 if (rc)
1066 return rc;
1067
1068 pSMB->BufferFormat = 0x04;
1069 pSMB->Tid2 = target_tid;
1070
1071 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
1072
1073 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1074 name_len = cifs_strtoUCS((wchar_t *) pSMB->OldFileName,
1075 fromName,
1076 530 /* find define for this maxpathcomponent */,
1077 nls_codepage);
1078 name_len++; /* trailing null */
1079 name_len *= 2;
1080 pSMB->OldFileName[name_len] = 0x04; /* pad */
1081 /* protocol requires ASCII signature byte on Unicode string */
1082 pSMB->OldFileName[name_len + 1] = 0x00;
1083 name_len2 = cifs_strtoUCS((wchar_t *) & pSMB->
1084 OldFileName[name_len + 2], toName, 530,
1085 nls_codepage);
1086 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1087 name_len2 *= 2; /* convert to bytes */
1088 } else { /* BB improve the check for buffer overruns BB */
1089 name_len = strnlen(fromName, 530);
1090 name_len++; /* trailing null */
1091 strncpy(pSMB->OldFileName, fromName, name_len);
1092 name_len2 = strnlen(toName, 530);
1093 name_len2++; /* trailing null */
1094 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1095 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1096 name_len2++; /* trailing null */
1097 name_len2++; /* signature byte */
1098 }
1099
1100 count = 1 /* 1st signature byte */ + name_len + name_len2;
1101 pSMB->hdr.smb_buf_length += count;
1102 pSMB->ByteCount = cpu_to_le16(count);
1103
1104 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1105 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1106 if (rc) {
1107 cFYI(1, ("Send error in copy = %d with %d files copied",
1108 rc, le16_to_cpu(pSMBr->CopyCount)));
1109 }
1110 if (pSMB)
1111 cifs_buf_release(pSMB);
1112
1113 if (rc == -EAGAIN)
1114 goto copyRetry;
1115
1116 return rc;
1117 }
1118
1119 int
1120 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
1121 const char *fromName, const char *toName,
1122 const struct nls_table *nls_codepage)
1123 {
1124 TRANSACTION2_SPI_REQ *pSMB = NULL;
1125 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1126 char *data_offset;
1127 int name_len;
1128 int name_len_target;
1129 int rc = 0;
1130 int bytes_returned = 0;
1131 __u16 params, param_offset, offset, byte_count;
1132
1133 cFYI(1, ("In Symlink Unix style"));
1134 createSymLinkRetry:
1135 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1136 (void **) &pSMBr);
1137 if (rc)
1138 return rc;
1139
1140 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1141 name_len =
1142 cifs_strtoUCS((wchar_t *) pSMB->FileName, fromName, 530
1143 /* find define for this maxpathcomponent */
1144 , nls_codepage);
1145 name_len++; /* trailing null */
1146 name_len *= 2;
1147
1148 } else { /* BB improve the check for buffer overruns BB */
1149 name_len = strnlen(fromName, 530);
1150 name_len++; /* trailing null */
1151 strncpy(pSMB->FileName, fromName, name_len);
1152 }
1153 params = 6 + name_len;
1154 pSMB->MaxSetupCount = 0;
1155 pSMB->Reserved = 0;
1156 pSMB->Flags = 0;
1157 pSMB->Timeout = 0;
1158 pSMB->Reserved2 = 0;
1159 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1160 InformationLevel) - 4;
1161 offset = param_offset + params;
1162
1163 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1164 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1165 name_len_target =
1166 cifs_strtoUCS((wchar_t *) data_offset, toName, 530
1167 /* find define for this maxpathcomponent */
1168 , nls_codepage);
1169 name_len_target++; /* trailing null */
1170 name_len_target *= 2;
1171 } else { /* BB improve the check for buffer overruns BB */
1172 name_len_target = strnlen(toName, 530);
1173 name_len_target++; /* trailing null */
1174 strncpy(data_offset, toName, name_len_target);
1175 }
1176
1177 pSMB->MaxParameterCount = cpu_to_le16(2);
1178 /* BB find exact max on data count below from sess */
1179 pSMB->MaxDataCount = cpu_to_le16(1000);
1180 pSMB->SetupCount = 1;
1181 pSMB->Reserved3 = 0;
1182 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1183 byte_count = 3 /* pad */ + params + name_len_target;
1184 pSMB->DataCount = cpu_to_le16(name_len_target);
1185 pSMB->ParameterCount = cpu_to_le16(params);
1186 pSMB->TotalDataCount = pSMB->DataCount;
1187 pSMB->TotalParameterCount = pSMB->ParameterCount;
1188 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1189 pSMB->DataOffset = cpu_to_le16(offset);
1190 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
1191 pSMB->Reserved4 = 0;
1192 pSMB->hdr.smb_buf_length += byte_count;
1193 pSMB->ByteCount = cpu_to_le16(byte_count);
1194 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1195 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1196 if (rc) {
1197 cFYI(1,
1198 ("Send error in SetPathInfo (create symlink) = %d",
1199 rc));
1200 }
1201
1202 if (pSMB)
1203 cifs_buf_release(pSMB);
1204
1205 if (rc == -EAGAIN)
1206 goto createSymLinkRetry;
1207
1208 return rc;
1209 }
1210
1211 int
1212 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1213 const char *fromName, const char *toName,
1214 const struct nls_table *nls_codepage)
1215 {
1216 TRANSACTION2_SPI_REQ *pSMB = NULL;
1217 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1218 char *data_offset;
1219 int name_len;
1220 int name_len_target;
1221 int rc = 0;
1222 int bytes_returned = 0;
1223 __u16 params, param_offset, offset, byte_count;
1224
1225 cFYI(1, ("In Create Hard link Unix style"));
1226 createHardLinkRetry:
1227 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1228 (void **) &pSMBr);
1229 if (rc)
1230 return rc;
1231
1232 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1233 name_len = cifs_strtoUCS((wchar_t *) pSMB->FileName, toName, 530
1234 /* find define for this maxpathcomponent */
1235 , nls_codepage);
1236 name_len++; /* trailing null */
1237 name_len *= 2;
1238
1239 } else { /* BB improve the check for buffer overruns BB */
1240 name_len = strnlen(toName, 530);
1241 name_len++; /* trailing null */
1242 strncpy(pSMB->FileName, toName, name_len);
1243 }
1244 params = 6 + name_len;
1245 pSMB->MaxSetupCount = 0;
1246 pSMB->Reserved = 0;
1247 pSMB->Flags = 0;
1248 pSMB->Timeout = 0;
1249 pSMB->Reserved2 = 0;
1250 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1251 InformationLevel) - 4;
1252 offset = param_offset + params;
1253
1254 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1255 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1256 name_len_target =
1257 cifs_strtoUCS((wchar_t *) data_offset, fromName, 530
1258 /* find define for this maxpathcomponent */
1259 , nls_codepage);
1260 name_len_target++; /* trailing null */
1261 name_len_target *= 2;
1262 } else { /* BB improve the check for buffer overruns BB */
1263 name_len_target = strnlen(fromName, 530);
1264 name_len_target++; /* trailing null */
1265 strncpy(data_offset, fromName, name_len_target);
1266 }
1267
1268 pSMB->MaxParameterCount = cpu_to_le16(2);
1269 /* BB find exact max on data count below from sess*/
1270 pSMB->MaxDataCount = cpu_to_le16(1000);
1271 pSMB->SetupCount = 1;
1272 pSMB->Reserved3 = 0;
1273 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1274 byte_count = 3 /* pad */ + params + name_len_target;
1275 pSMB->ParameterCount = cpu_to_le16(params);
1276 pSMB->TotalParameterCount = pSMB->ParameterCount;
1277 pSMB->DataCount = cpu_to_le16(name_len_target);
1278 pSMB->TotalDataCount = pSMB->DataCount;
1279 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1280 pSMB->DataOffset = cpu_to_le16(offset);
1281 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
1282 pSMB->Reserved4 = 0;
1283 pSMB->hdr.smb_buf_length += byte_count;
1284 pSMB->ByteCount = cpu_to_le16(byte_count);
1285 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1286 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1287 if (rc) {
1288 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
1289 }
1290
1291 if (pSMB)
1292 cifs_buf_release(pSMB);
1293 if (rc == -EAGAIN)
1294 goto createHardLinkRetry;
1295
1296 return rc;
1297 }
1298
1299 int
1300 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1301 const char *fromName, const char *toName,
1302 const struct nls_table *nls_codepage)
1303 {
1304 int rc = 0;
1305 NT_RENAME_REQ *pSMB = NULL;
1306 RENAME_RSP *pSMBr = NULL;
1307 int bytes_returned;
1308 int name_len, name_len2;
1309 __u16 count;
1310
1311 cFYI(1, ("In CIFSCreateHardLink"));
1312 winCreateHardLinkRetry:
1313
1314 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
1315 (void **) &pSMBr);
1316 if (rc)
1317 return rc;
1318
1319 pSMB->SearchAttributes =
1320 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1321 ATTR_DIRECTORY);
1322 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
1323 pSMB->ClusterCount = 0;
1324
1325 pSMB->BufferFormat = 0x04;
1326
1327 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1328 name_len =
1329 cifs_strtoUCS((wchar_t *) pSMB->OldFileName, fromName, 530
1330 /* find define for this maxpathcomponent */
1331 , nls_codepage);
1332 name_len++; /* trailing null */
1333 name_len *= 2;
1334 pSMB->OldFileName[name_len] = 0; /* pad */
1335 pSMB->OldFileName[name_len + 1] = 0x04;
1336 name_len2 =
1337 cifs_strtoUCS((wchar_t *) & pSMB->
1338 OldFileName[name_len + 2], toName, 530,
1339 nls_codepage);
1340 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1341 name_len2 *= 2; /* convert to bytes */
1342 } else { /* BB improve the check for buffer overruns BB */
1343 name_len = strnlen(fromName, 530);
1344 name_len++; /* trailing null */
1345 strncpy(pSMB->OldFileName, fromName, name_len);
1346 name_len2 = strnlen(toName, 530);
1347 name_len2++; /* trailing null */
1348 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1349 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1350 name_len2++; /* trailing null */
1351 name_len2++; /* signature byte */
1352 }
1353
1354 count = 1 /* string type byte */ + name_len + name_len2;
1355 pSMB->hdr.smb_buf_length += count;
1356 pSMB->ByteCount = cpu_to_le16(count);
1357
1358 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1359 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1360 if (rc) {
1361 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
1362 }
1363 if (pSMB)
1364 cifs_buf_release(pSMB);
1365 if (rc == -EAGAIN)
1366 goto winCreateHardLinkRetry;
1367
1368 return rc;
1369 }
1370
1371 int
1372 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
1373 const unsigned char *searchName,
1374 char *symlinkinfo, const int buflen,
1375 const struct nls_table *nls_codepage)
1376 {
1377 /* SMB_QUERY_FILE_UNIX_LINK */
1378 TRANSACTION2_QPI_REQ *pSMB = NULL;
1379 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1380 int rc = 0;
1381 int bytes_returned;
1382 int name_len;
1383 __u16 params, byte_count;
1384
1385 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
1386
1387 querySymLinkRetry:
1388 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1389 (void **) &pSMBr);
1390 if (rc)
1391 return rc;
1392
1393 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1394 name_len =
1395 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
1396 /* find define for this maxpathcomponent */
1397 , nls_codepage);
1398 name_len++; /* trailing null */
1399 name_len *= 2;
1400 } else { /* BB improve the check for buffer overruns BB */
1401 name_len = strnlen(searchName, 530);
1402 name_len++; /* trailing null */
1403 strncpy(pSMB->FileName, searchName, name_len);
1404 }
1405
1406 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
1407 pSMB->TotalDataCount = 0;
1408 pSMB->MaxParameterCount = cpu_to_le16(2);
1409 /* BB find exact max data count below from sess structure BB */
1410 pSMB->MaxDataCount = cpu_to_le16(4000);
1411 pSMB->MaxSetupCount = 0;
1412 pSMB->Reserved = 0;
1413 pSMB->Flags = 0;
1414 pSMB->Timeout = 0;
1415 pSMB->Reserved2 = 0;
1416 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1417 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1418 pSMB->DataCount = 0;
1419 pSMB->DataOffset = 0;
1420 pSMB->SetupCount = 1;
1421 pSMB->Reserved3 = 0;
1422 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1423 byte_count = params + 1 /* pad */ ;
1424 pSMB->TotalParameterCount = cpu_to_le16(params);
1425 pSMB->ParameterCount = pSMB->TotalParameterCount;
1426 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
1427 pSMB->Reserved4 = 0;
1428 pSMB->hdr.smb_buf_length += byte_count;
1429 pSMB->ByteCount = cpu_to_le16(byte_count);
1430
1431 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1432 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1433 if (rc) {
1434 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
1435 } else { /* decode response */
1436 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
1437 __u16 count = le16_to_cpu(pSMBr->DataCount);
1438 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
1439 /* BB also check enough total bytes returned */
1440 rc = -EIO; /* bad smb */
1441 else {
1442 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1443 name_len = UniStrnlen((wchar_t *) ((char *)
1444 &pSMBr->hdr.Protocol +data_offset),
1445 min_t(const int, buflen,count) / 2);
1446 cifs_strfromUCS_le(symlinkinfo,
1447 (wchar_t *) ((char *)&pSMBr->hdr.Protocol +
1448 data_offset),
1449 name_len, nls_codepage);
1450 } else {
1451 strncpy(symlinkinfo,
1452 (char *) &pSMBr->hdr.Protocol +
1453 data_offset,
1454 min_t(const int, buflen, count));
1455 }
1456 symlinkinfo[buflen] = 0;
1457 /* just in case so calling code does not go off the end of buffer */
1458 }
1459 }
1460 if (pSMB)
1461 cifs_buf_release(pSMB);
1462 if (rc == -EAGAIN)
1463 goto querySymLinkRetry;
1464 return rc;
1465 }
1466
1467
1468
1469 int
1470 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
1471 const unsigned char *searchName,
1472 char *symlinkinfo, const int buflen,__u16 fid,
1473 const struct nls_table *nls_codepage)
1474 {
1475 int rc = 0;
1476 int bytes_returned;
1477 int name_len;
1478 struct smb_com_transaction_ioctl_req * pSMB;
1479 struct smb_com_transaction_ioctl_rsp * pSMBr;
1480
1481 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
1482 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
1483 (void **) &pSMBr);
1484 if (rc)
1485 return rc;
1486
1487 pSMB->TotalParameterCount = 0 ;
1488 pSMB->TotalDataCount = 0;
1489 pSMB->MaxParameterCount = cpu_to_le32(2);
1490 /* BB find exact data count max from sess structure BB */
1491 pSMB->MaxDataCount = cpu_to_le32(4000);
1492 pSMB->MaxSetupCount = 4;
1493 pSMB->Reserved = 0;
1494 pSMB->ParameterOffset = 0;
1495 pSMB->DataCount = 0;
1496 pSMB->DataOffset = 0;
1497 pSMB->SetupCount = 4;
1498 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
1499 pSMB->ParameterCount = pSMB->TotalParameterCount;
1500 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
1501 pSMB->IsFsctl = 1; /* FSCTL */
1502 pSMB->IsRootFlag = 0;
1503 pSMB->Fid = fid; /* file handle always le */
1504 pSMB->ByteCount = 0;
1505
1506 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1507 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1508 if (rc) {
1509 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
1510 } else { /* decode response */
1511 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
1512 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
1513 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
1514 /* BB also check enough total bytes returned */
1515 rc = -EIO; /* bad smb */
1516 else {
1517 if(data_count && (data_count < 2048)) {
1518 /* could also validate reparse tag && better check name length */
1519 struct reparse_data * reparse_buf = (struct reparse_data *)
1520 ((char *)&pSMBr->hdr.Protocol + data_offset);
1521 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
1522 name_len = UniStrnlen((wchar_t *)
1523 (reparse_buf->LinkNamesBuf +
1524 reparse_buf->TargetNameOffset),
1525 min(buflen/2, reparse_buf->TargetNameLen / 2));
1526 cifs_strfromUCS_le(symlinkinfo,
1527 (wchar_t *) (reparse_buf->LinkNamesBuf +
1528 reparse_buf->TargetNameOffset),
1529 name_len, nls_codepage);
1530 } else { /* ASCII names */
1531 strncpy(symlinkinfo,reparse_buf->LinkNamesBuf +
1532 reparse_buf->TargetNameOffset,
1533 min_t(const int, buflen, reparse_buf->TargetNameLen));
1534 }
1535 } else {
1536 rc = -EIO;
1537 cFYI(1,("Invalid return data count on get reparse info ioctl"));
1538 }
1539 symlinkinfo[buflen] = 0; /* just in case so the caller
1540 does not go off the end of the buffer */
1541 cFYI(1,("readlink result - %s ",symlinkinfo));
1542 }
1543 }
1544 if (pSMB)
1545 cifs_buf_release(pSMB);
1546
1547 /* Note: On -EAGAIN error only caller can retry on handle based calls
1548 since file handle passed in no longer valid */
1549
1550 return rc;
1551 }
1552
1553 int
1554 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
1555 const unsigned char *searchName,
1556 FILE_ALL_INFO * pFindData,
1557 const struct nls_table *nls_codepage)
1558 {
1559 /* level 263 SMB_QUERY_FILE_ALL_INFO */
1560 TRANSACTION2_QPI_REQ *pSMB = NULL;
1561 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1562 int rc = 0;
1563 int bytes_returned;
1564 int name_len;
1565 __u16 params, byte_count;
1566
1567 cFYI(1, ("In QPathInfo path %s", searchName));
1568 QPathInfoRetry:
1569 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1570 (void **) &pSMBr);
1571 if (rc)
1572 return rc;
1573
1574 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1575 name_len =
1576 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
1577 /* find define for this maxpathcomponent */
1578 , nls_codepage);
1579 name_len++; /* trailing null */
1580 name_len *= 2;
1581 } else { /* BB improve the check for buffer overruns BB */
1582 name_len = strnlen(searchName, 530);
1583 name_len++; /* trailing null */
1584 strncpy(pSMB->FileName, searchName, name_len);
1585 }
1586
1587 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
1588 pSMB->TotalDataCount = 0;
1589 pSMB->MaxParameterCount = cpu_to_le16(2);
1590 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
1591 pSMB->MaxSetupCount = 0;
1592 pSMB->Reserved = 0;
1593 pSMB->Flags = 0;
1594 pSMB->Timeout = 0;
1595 pSMB->Reserved2 = 0;
1596 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1597 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1598 pSMB->DataCount = 0;
1599 pSMB->DataOffset = 0;
1600 pSMB->SetupCount = 1;
1601 pSMB->Reserved3 = 0;
1602 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1603 byte_count = params + 1 /* pad */ ;
1604 pSMB->TotalParameterCount = cpu_to_le16(params);
1605 pSMB->ParameterCount = pSMB->TotalParameterCount;
1606 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
1607 pSMB->Reserved4 = 0;
1608 pSMB->hdr.smb_buf_length += byte_count;
1609 pSMB->ByteCount = cpu_to_le16(byte_count);
1610
1611 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1612 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1613 if (rc) {
1614 cFYI(1, ("Send error in QPathInfo = %d", rc));
1615 } else { /* decode response */
1616 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
1617 /* BB also check enough total bytes returned */
1618 /* BB we need to improve the validity checking
1619 of these trans2 responses */
1620 if ((pSMBr->ByteCount < 40) || (data_offset > 512))
1621 rc = -EIO; /* bad smb */
1622 else if (pFindData){
1623 memcpy((char *) pFindData,
1624 (char *) &pSMBr->hdr.Protocol +
1625 data_offset, sizeof (FILE_ALL_INFO));
1626 } else
1627 rc = -ENOMEM;
1628 }
1629 if (pSMB)
1630 cifs_buf_release(pSMB);
1631 if (rc == -EAGAIN)
1632 goto QPathInfoRetry;
1633
1634 return rc;
1635 }
1636
1637 int
1638 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
1639 const unsigned char *searchName,
1640 FILE_UNIX_BASIC_INFO * pFindData,
1641 const struct nls_table *nls_codepage)
1642 {
1643 /* SMB_QUERY_FILE_UNIX_BASIC */
1644 TRANSACTION2_QPI_REQ *pSMB = NULL;
1645 TRANSACTION2_QPI_RSP *pSMBr = NULL;
1646 int rc = 0;
1647 int bytes_returned = 0;
1648 int name_len;
1649 __u16 params, byte_count;
1650
1651 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
1652 UnixQPathInfoRetry:
1653 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1654 (void **) &pSMBr);
1655 if (rc)
1656 return rc;
1657
1658 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1659 name_len =
1660 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
1661 /* find define for this maxpathcomponent */
1662 , nls_codepage);
1663 name_len++; /* trailing null */
1664 name_len *= 2;
1665 } else { /* BB improve the check for buffer overruns BB */
1666 name_len = strnlen(searchName, 530);
1667 name_len++; /* trailing null */
1668 strncpy(pSMB->FileName, searchName, name_len);
1669 }
1670
1671 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
1672 pSMB->TotalDataCount = 0;
1673 pSMB->MaxParameterCount = cpu_to_le16(2);
1674 /* BB find exact max SMB PDU from sess structure BB */
1675 pSMB->MaxDataCount = cpu_to_le16(4000);
1676 pSMB->MaxSetupCount = 0;
1677 pSMB->Reserved = 0;
1678 pSMB->Flags = 0;
1679 pSMB->Timeout = 0;
1680 pSMB->Reserved2 = 0;
1681 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1682 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
1683 pSMB->DataCount = 0;
1684 pSMB->DataOffset = 0;
1685 pSMB->SetupCount = 1;
1686 pSMB->Reserved3 = 0;
1687 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
1688 byte_count = params + 1 /* pad */ ;
1689 pSMB->TotalParameterCount = cpu_to_le16(params);
1690 pSMB->ParameterCount = pSMB->TotalParameterCount;
1691 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1692 pSMB->Reserved4 = 0;
1693 pSMB->hdr.smb_buf_length += byte_count;
1694 pSMB->ByteCount = cpu_to_le16(byte_count);
1695
1696 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1697 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1698 if (rc) {
1699 cFYI(1, ("Send error in QPathInfo = %d", rc));
1700 } else { /* decode response */
1701 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
1702 /* BB also check if enough total bytes returned */
1703 if ((pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO)) ||
1704 (data_offset > 512) ||
1705 (data_offset < sizeof(struct smb_hdr))) {
1706 cFYI(1,("UnixQPathinfo invalid data offset %d bytes returned %d",
1707 (int)data_offset,bytes_returned));
1708 rc = -EIO; /* bad smb */
1709 } else {
1710 memcpy((char *) pFindData,
1711 (char *) &pSMBr->hdr.Protocol +
1712 data_offset,
1713 sizeof (FILE_UNIX_BASIC_INFO));
1714 }
1715 }
1716 if (pSMB)
1717 cifs_buf_release(pSMB);
1718 if (rc == -EAGAIN)
1719 goto UnixQPathInfoRetry;
1720
1721 return rc;
1722 }
1723
1724 int
1725 CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
1726 const char *searchName, FILE_ALL_INFO * findData,
1727 const struct nls_table *nls_codepage)
1728 {
1729 /* level 257 SMB_ */
1730 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
1731 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
1732 int rc = 0;
1733 int bytes_returned;
1734 int name_len;
1735 __u16 params, byte_count;
1736
1737 cFYI(1, ("In FindUnique"));
1738 findUniqueRetry:
1739 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1740 (void **) &pSMBr);
1741 if (rc)
1742 return rc;
1743
1744 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1745 name_len =
1746 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
1747 /* find define for this maxpathcomponent */
1748 , nls_codepage);
1749 name_len++; /* trailing null */
1750 name_len *= 2;
1751 } else { /* BB improve the check for buffer overruns BB */
1752 name_len = strnlen(searchName, 530);
1753 name_len++; /* trailing null */
1754 strncpy(pSMB->FileName, searchName, name_len);
1755 }
1756
1757 params = 12 + name_len /* includes null */ ;
1758 pSMB->TotalDataCount = 0; /* no EAs */
1759 pSMB->MaxParameterCount = cpu_to_le16(2);
1760 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
1761 pSMB->MaxSetupCount = 0;
1762 pSMB->Reserved = 0;
1763 pSMB->Flags = 0;
1764 pSMB->Timeout = 0;
1765 pSMB->Reserved2 = 0;
1766 pSMB->ParameterOffset = cpu_to_le16(
1767 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
1768 pSMB->DataCount = 0;
1769 pSMB->DataOffset = 0;
1770 pSMB->SetupCount = 1; /* one byte, no need to le convert */
1771 pSMB->Reserved3 = 0;
1772 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
1773 byte_count = params + 1 /* pad */ ;
1774 pSMB->TotalParameterCount = cpu_to_le16(params);
1775 pSMB->ParameterCount = pSMB->TotalParameterCount;
1776 pSMB->SearchAttributes =
1777 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1778 ATTR_DIRECTORY);
1779 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
1780 pSMB->SearchFlags = cpu_to_le16(1);
1781 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
1782 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
1783 pSMB->hdr.smb_buf_length += byte_count;
1784 pSMB->ByteCount = cpu_to_le16(byte_count);
1785
1786 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1787 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1788
1789 if (rc) {
1790 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
1791 } else { /* decode response */
1792
1793 /* BB fill in */
1794 }
1795 if (pSMB)
1796 cifs_buf_release(pSMB);
1797 if (rc == -EAGAIN)
1798 goto findUniqueRetry;
1799
1800 return rc;
1801 }
1802
1803 int
1804 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
1805 const char *searchName, FILE_DIRECTORY_INFO * findData,
1806 T2_FFIRST_RSP_PARMS * findParms,
1807 const struct nls_table *nls_codepage, int *pUnicodeFlag,
1808 int *pUnixFlag)
1809 {
1810 /* level 257 SMB_ */
1811 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
1812 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
1813 char *response_data;
1814 int rc = 0;
1815 int bytes_returned;
1816 int name_len;
1817 __u16 params, byte_count;
1818
1819 cFYI(1, ("In FindFirst"));
1820 findFirstRetry:
1821 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1822 (void **) &pSMBr);
1823 if (rc)
1824 return rc;
1825
1826 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1827 name_len =
1828 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
1829 /* find define for this maxpathcomponent */
1830 , nls_codepage);
1831 name_len++; /* trailing null */
1832 name_len *= 2;
1833 } else { /* BB improve the check for buffer overruns BB */
1834 name_len = strnlen(searchName, 530);
1835 name_len++; /* trailing null */
1836 strncpy(pSMB->FileName, searchName, name_len);
1837 }
1838
1839 params = 12 + name_len /* includes null */ ;
1840 pSMB->TotalDataCount = 0; /* no EAs */
1841 pSMB->MaxParameterCount = cpu_to_le16(10);
1842 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
1843 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
1844 pSMB->MaxSetupCount = 0;
1845 pSMB->Reserved = 0;
1846 pSMB->Flags = 0;
1847 pSMB->Timeout = 0;
1848 pSMB->Reserved2 = 0;
1849 byte_count = params + 1 /* pad */ ;
1850 pSMB->TotalParameterCount = cpu_to_le16(params);
1851 pSMB->ParameterCount = pSMB->TotalParameterCount;
1852 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
1853 smb_com_transaction2_ffirst_req, SearchAttributes) - 4);
1854 pSMB->DataCount = 0;
1855 pSMB->DataOffset = 0;
1856 pSMB->SetupCount = 1; /* one byte no need to make endian neutral */
1857 pSMB->Reserved3 = 0;
1858 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
1859 pSMB->SearchAttributes =
1860 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1861 ATTR_DIRECTORY);
1862 pSMB->SearchCount = cpu_to_le16(CIFS_MAX_MSGSIZE / sizeof (FILE_DIRECTORY_INFO)); /* should this be shrunk even more ? */
1863 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
1864
1865 /* test for Unix extensions */
1866 if (tcon->ses->capabilities & CAP_UNIX) {
1867 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
1868 *pUnixFlag = TRUE;
1869 } else {
1870 pSMB->InformationLevel =
1871 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
1872 *pUnixFlag = FALSE;
1873 }
1874 pSMB->SearchStorageType = 0; /* BB what should we set this to? It is not clear if it matters BB */
1875 pSMB->hdr.smb_buf_length += byte_count;
1876 pSMB->ByteCount = cpu_to_le16(byte_count);
1877
1878 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1879 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1880
1881 if (rc) { /* BB add logic to retry regular search if Unix search rejected unexpectedly by server */
1882 cFYI(1, ("Error in FindFirst = %d", rc));
1883 } else { /* decode response */
1884 /* BB add safety checks for these memcpys */
1885 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
1886 *pUnicodeFlag = TRUE;
1887 else
1888 *pUnicodeFlag = FALSE;
1889 memcpy(findParms,
1890 (char *) &pSMBr->hdr.Protocol +
1891 le16_to_cpu(pSMBr->ParameterOffset),
1892 sizeof (T2_FFIRST_RSP_PARMS));
1893 response_data =
1894 (char *) &pSMBr->hdr.Protocol +
1895 le16_to_cpu(pSMBr->DataOffset);
1896 memcpy(findData, response_data, le16_to_cpu(pSMBr->DataCount));
1897 }
1898 if (pSMB)
1899 cifs_buf_release(pSMB);
1900
1901 if (rc == -EAGAIN)
1902 goto findFirstRetry;
1903
1904 return rc;
1905 }
1906
1907 int
1908 CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
1909 FILE_DIRECTORY_INFO * findData, T2_FNEXT_RSP_PARMS * findParms,
1910 const __u16 searchHandle, char * resume_file_name, int name_len,
1911 __u32 resume_key, int *pUnicodeFlag, int *pUnixFlag)
1912 {
1913 /* level 257 SMB_ */
1914 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
1915 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
1916 char *response_data;
1917 int rc = 0;
1918 int bytes_returned;
1919 __u16 params, byte_count;
1920
1921 cFYI(1, ("In FindNext"));
1922
1923 if(resume_file_name == NULL) {
1924 return -EIO;
1925 }
1926 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1927 (void **) &pSMBr);
1928 if (rc)
1929 return rc;
1930
1931 params = 14; /* includes 2 bytes of null string, converted to LE below */
1932 byte_count = 0;
1933 pSMB->TotalDataCount = 0; /* no EAs */
1934 pSMB->MaxParameterCount = cpu_to_le16(8);
1935 pSMB->MaxDataCount =
1936 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
1937 pSMB->MaxSetupCount = 0;
1938 pSMB->Reserved = 0;
1939 pSMB->Flags = 0;
1940 pSMB->Timeout = 0;
1941 pSMB->Reserved2 = 0;
1942 pSMB->ParameterOffset = cpu_to_le16(offsetof(
1943 struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
1944 pSMB->DataCount = 0;
1945 pSMB->DataOffset = 0;
1946 pSMB->SetupCount = 1;
1947 pSMB->Reserved3 = 0;
1948 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
1949 pSMB->SearchHandle = searchHandle; /* always kept as le */
1950 findParms->SearchCount = 0; /* set to zero in case of error */
1951 pSMB->SearchCount =
1952 cpu_to_le16(CIFS_MAX_MSGSIZE / sizeof (FILE_DIRECTORY_INFO));
1953 /* test for Unix extensions */
1954 if (tcon->ses->capabilities & CAP_UNIX) {
1955 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
1956 *pUnixFlag = TRUE;
1957 } else {
1958 pSMB->InformationLevel =
1959 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
1960 *pUnixFlag = FALSE;
1961 }
1962 pSMB->ResumeKey = resume_key;
1963 pSMB->SearchFlags =
1964 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
1965 /* BB add check to make sure we do not cross end of smb */
1966 if(name_len < CIFS_MAX_MSGSIZE) {
1967 memcpy(pSMB->ResumeFileName, resume_file_name, name_len);
1968 byte_count += name_len;
1969 }
1970 params += name_len;
1971 byte_count = params + 1 /* pad */ ;
1972 pSMB->TotalParameterCount = cpu_to_le16(params);
1973 pSMB->ParameterCount = pSMB->TotalParameterCount;
1974 /* BB improve error handling here */
1975 pSMB->hdr.smb_buf_length += byte_count;
1976 pSMB->ByteCount = cpu_to_le16(byte_count);
1977
1978 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1979 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1980
1981 if (rc) {
1982 if (rc == -EBADF)
1983 rc = 0; /* search probably was closed at end of search above */
1984 else
1985 cFYI(1, ("FindNext returned = %d", rc));
1986 } else { /* decode response */
1987 /* BB add safety checks for these memcpys */
1988 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
1989 *pUnicodeFlag = TRUE;
1990 else
1991 *pUnicodeFlag = FALSE;
1992 memcpy(findParms,
1993 (char *) &pSMBr->hdr.Protocol +
1994 le16_to_cpu(pSMBr->ParameterOffset),
1995 sizeof (T2_FNEXT_RSP_PARMS));
1996 response_data =
1997 (char *) &pSMBr->hdr.Protocol +
1998 le16_to_cpu(pSMBr->DataOffset);
1999 memcpy(findData, response_data, le16_to_cpu(pSMBr->DataCount));
2000 }
2001 if (pSMB)
2002 cifs_buf_release(pSMB);
2003
2004 /* Note: On -EAGAIN error only caller can retry on handle based calls
2005 since file handle passed in no longer valid */
2006
2007 return rc;
2008 }
2009
2010 int
2011 CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
2012 {
2013 int rc = 0;
2014 FINDCLOSE_REQ *pSMB = NULL;
2015 CLOSE_RSP *pSMBr = NULL;
2016 int bytes_returned;
2017
2018 cFYI(1, ("In CIFSSMBFindClose"));
2019 rc = smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **) &pSMB,
2020 (void **) &pSMBr);
2021 /* no sense returning error if session restarted
2022 file handle has been closed */
2023 if(rc == -EAGAIN)
2024 return 0;
2025 if (rc)
2026 return rc;
2027
2028 pSMB->FileID = searchHandle;
2029 pSMB->ByteCount = 0;
2030 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2031 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2032 if (rc) {
2033 cERROR(1, ("Send error in FindClose = %d", rc));
2034 }
2035 if (pSMB)
2036 cifs_buf_release(pSMB);
2037
2038 /* Since session is dead, search handle closed on server already */
2039 if (rc == -EAGAIN)
2040 rc = 0;
2041
2042 return rc;
2043 }
2044
2045 int
2046 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
2047 const unsigned char *searchName,
2048 unsigned char **targetUNCs,
2049 unsigned int *number_of_UNC_in_array,
2050 const struct nls_table *nls_codepage)
2051 {
2052 /* TRANS2_GET_DFS_REFERRAL */
2053 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
2054 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
2055 struct dfs_referral_level_3 * referrals = NULL;
2056 int rc = 0;
2057 int bytes_returned;
2058 int name_len;
2059 unsigned int i;
2060 char * temp;
2061 __u16 params, byte_count;
2062 *number_of_UNC_in_array = 0;
2063 *targetUNCs = NULL;
2064
2065 cFYI(1, ("In GetDFSRefer the path %s", searchName));
2066 if (ses == NULL)
2067 return -ENODEV;
2068 getDFSRetry:
2069 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
2070 (void **) &pSMBr);
2071 if (rc)
2072 return rc;
2073
2074 pSMB->hdr.Tid = ses->ipc_tid;
2075 pSMB->hdr.Uid = ses->Suid;
2076 if (ses->capabilities & CAP_STATUS32) {
2077 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
2078 }
2079 if (ses->capabilities & CAP_DFS) {
2080 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
2081 }
2082
2083 if (ses->capabilities & CAP_UNICODE) {
2084 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
2085 name_len =
2086 cifs_strtoUCS((wchar_t *) pSMB->RequestFileName,
2087 searchName, 530
2088 /* find define for this maxpathcomponent */
2089 , nls_codepage);
2090 name_len++; /* trailing null */
2091 name_len *= 2;
2092 } else { /* BB improve the check for buffer overruns BB */
2093 name_len = strnlen(searchName, 530);
2094 name_len++; /* trailing null */
2095 strncpy(pSMB->RequestFileName, searchName, name_len);
2096 }
2097
2098 params = 2 /* level */ + name_len /*includes null */ ;
2099 pSMB->TotalDataCount = 0;
2100 pSMB->DataCount = 0;
2101 pSMB->DataOffset = 0;
2102 pSMB->MaxParameterCount = 0;
2103 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2104 pSMB->MaxSetupCount = 0;
2105 pSMB->Reserved = 0;
2106 pSMB->Flags = 0;
2107 pSMB->Timeout = 0;
2108 pSMB->Reserved2 = 0;
2109 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2110 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
2111 pSMB->SetupCount = 1;
2112 pSMB->Reserved3 = 0;
2113 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
2114 byte_count = params + 3 /* pad */ ;
2115 pSMB->ParameterCount = cpu_to_le16(params);
2116 pSMB->TotalParameterCount = pSMB->ParameterCount;
2117 pSMB->MaxReferralLevel = cpu_to_le16(3);
2118 pSMB->hdr.smb_buf_length += byte_count;
2119 pSMB->ByteCount = cpu_to_le16(byte_count);
2120
2121 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
2122 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2123 if (rc) {
2124 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
2125 } else { /* decode response */
2126 /* BB Add logic to parse referrals here */
2127 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
2128 __u16 data_count = le16_to_cpu(pSMBr->DataCount);
2129 cFYI(1,
2130 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
2131 pSMBr->ByteCount, data_offset));
2132 if ((pSMBr->ByteCount < 17) || (data_offset > 512)) /* BB also check enough total bytes returned */
2133 rc = -EIO; /* bad smb */
2134 else {
2135 referrals =
2136 (struct dfs_referral_level_3 *)
2137 (8 /* sizeof start of data block */ +
2138 data_offset +
2139 (char *) &pSMBr->hdr.Protocol);
2140 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",
2141 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)));
2142 /* BB This field is actually two bytes in from start of
2143 data block so we could do safety check that DataBlock
2144 begins at address of pSMBr->NumberOfReferrals */
2145 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
2146
2147 /* BB Fix below so can return more than one referral */
2148 if(*number_of_UNC_in_array > 1)
2149 *number_of_UNC_in_array = 1;
2150
2151 /* get the length of the strings describing refs */
2152 name_len = 0;
2153 for(i=0;i<*number_of_UNC_in_array;i++) {
2154 /* make sure that DfsPathOffset not past end */
2155 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
2156 if (offset > data_count) {
2157 /* if invalid referral, stop here and do
2158 not try to copy any more */
2159 *number_of_UNC_in_array = i;
2160 break;
2161 }
2162 temp = ((char *)referrals) + offset;
2163
2164 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2165 name_len += UniStrnlen((wchar_t *)temp,data_count);
2166 } else {
2167 name_len += strnlen(temp,data_count);
2168 }
2169 referrals++;
2170 /* BB add check that referral pointer does not fall off end PDU */
2171
2172 }
2173 /* BB add check for name_len bigger than bcc */
2174 *targetUNCs =
2175 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
2176 if(*targetUNCs == NULL) {
2177 rc = -ENOMEM;
2178 goto GetDFSRefExit;
2179 }
2180 /* copy the ref strings */
2181 referrals =
2182 (struct dfs_referral_level_3 *)
2183 (8 /* sizeof data hdr */ +
2184 data_offset +
2185 (char *) &pSMBr->hdr.Protocol);
2186
2187 for(i=0;i<*number_of_UNC_in_array;i++) {
2188 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
2189 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2190 cifs_strfromUCS_le(*targetUNCs,
2191 (wchar_t *) temp, name_len, nls_codepage);
2192 } else {
2193 strncpy(*targetUNCs,temp,name_len);
2194 }
2195 /* BB update target_uncs pointers */
2196 referrals++;
2197 }
2198 temp = *targetUNCs;
2199 temp[name_len] = 0;
2200 }
2201
2202 }
2203 GetDFSRefExit:
2204 if (pSMB)
2205 cifs_buf_release(pSMB);
2206
2207 if (rc == -EAGAIN)
2208 goto getDFSRetry;
2209
2210 return rc;
2211 }
2212
2213 int
2214 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon,
2215 struct kstatfs *FSData, const struct nls_table *nls_codepage)
2216 {
2217 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
2218 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2219 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2220 FILE_SYSTEM_INFO *response_data;
2221 int rc = 0;
2222 int bytes_returned = 0;
2223 __u16 params, byte_count;
2224
2225 cFYI(1, ("In QFSInfo"));
2226 QFSInfoRetry:
2227 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2228 (void **) &pSMBr);
2229 if (rc)
2230 return rc;
2231
2232 params = 2; /* level */
2233 pSMB->TotalDataCount = 0;
2234 pSMB->MaxParameterCount = cpu_to_le16(2);
2235 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2236 pSMB->MaxSetupCount = 0;
2237 pSMB->Reserved = 0;
2238 pSMB->Flags = 0;
2239 pSMB->Timeout = 0;
2240 pSMB->Reserved2 = 0;
2241 byte_count = params + 1 /* pad */ ;
2242 pSMB->TotalParameterCount = cpu_to_le16(params);
2243 pSMB->ParameterCount = pSMB->TotalParameterCount;
2244 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2245 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2246 pSMB->DataCount = 0;
2247 pSMB->DataOffset = 0;
2248 pSMB->SetupCount = 1;
2249 pSMB->Reserved3 = 0;
2250 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2251 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
2252 pSMB->hdr.smb_buf_length += byte_count;
2253 pSMB->ByteCount = cpu_to_le16(byte_count);
2254
2255 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2256 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2257 if (rc) {
2258 cERROR(1, ("Send error in QFSInfo = %d", rc));
2259 } else { /* decode response */
2260 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
2261 cFYI(1,
2262 ("Decoding qfsinfo response. BCC: %d Offset %d",
2263 pSMBr->ByteCount, data_offset));
2264 if ((pSMBr->ByteCount < 24) || (data_offset > 512)) /* BB also check enough total bytes returned */
2265 rc = -EIO; /* bad smb */
2266 else {
2267 response_data =
2268 (FILE_SYSTEM_INFO
2269 *) (((char *) &pSMBr->hdr.Protocol) +
2270 data_offset);
2271 FSData->f_bsize =
2272 le32_to_cpu(response_data->BytesPerSector) *
2273 le32_to_cpu(response_data->
2274 SectorsPerAllocationUnit);
2275 FSData->f_blocks =
2276 le64_to_cpu(response_data->TotalAllocationUnits);
2277 FSData->f_bfree = FSData->f_bavail =
2278 le64_to_cpu(response_data->FreeAllocationUnits);
2279 cFYI(1,
2280 ("Blocks: %lld Free: %lld Block size %ld",
2281 (unsigned long long)FSData->f_blocks,
2282 (unsigned long long)FSData->f_bfree,
2283 FSData->f_bsize));
2284 }
2285 }
2286 if (pSMB)
2287 cifs_buf_release(pSMB);
2288
2289 if (rc == -EAGAIN)
2290 goto QFSInfoRetry;
2291
2292 return rc;
2293 }
2294
2295 int
2296 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon,
2297 const struct nls_table *nls_codepage)
2298 {
2299 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
2300 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2301 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2302 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
2303 int rc = 0;
2304 int bytes_returned = 0;
2305 __u16 params, byte_count;
2306
2307 cFYI(1, ("In QFSAttributeInfo"));
2308 QFSAttributeRetry:
2309 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2310 (void **) &pSMBr);
2311 if (rc)
2312 return rc;
2313
2314 params = 2; /* level */
2315 pSMB->TotalDataCount = 0;
2316 pSMB->MaxParameterCount = cpu_to_le16(2);
2317 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2318 pSMB->MaxSetupCount = 0;
2319 pSMB->Reserved = 0;
2320 pSMB->Flags = 0;
2321 pSMB->Timeout = 0;
2322 pSMB->Reserved2 = 0;
2323 byte_count = params + 1 /* pad */ ;
2324 pSMB->TotalParameterCount = cpu_to_le16(params);
2325 pSMB->ParameterCount = pSMB->TotalParameterCount;
2326 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2327 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2328 pSMB->DataCount = 0;
2329 pSMB->DataOffset = 0;
2330 pSMB->SetupCount = 1;
2331 pSMB->Reserved3 = 0;
2332 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2333 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
2334 pSMB->hdr.smb_buf_length += byte_count;
2335 pSMB->ByteCount = cpu_to_le16(byte_count);
2336
2337 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2338 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2339 if (rc) {
2340 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
2341 } else { /* decode response */
2342 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
2343 if ((pSMBr->ByteCount < 13) || (data_offset > 512)) { /* BB also check enough bytes returned */
2344 rc = -EIO; /* bad smb */
2345 } else {
2346 response_data =
2347 (FILE_SYSTEM_ATTRIBUTE_INFO
2348 *) (((char *) &pSMBr->hdr.Protocol) +
2349 data_offset);
2350 memcpy(&tcon->fsAttrInfo, response_data,
2351 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
2352 }
2353 }
2354 if (pSMB)
2355 cifs_buf_release(pSMB);
2356
2357 if (rc == -EAGAIN)
2358 goto QFSAttributeRetry;
2359
2360 return rc;
2361 }
2362
2363 int
2364 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon,
2365 const struct nls_table *nls_codepage)
2366 {
2367 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
2368 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2369 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2370 FILE_SYSTEM_DEVICE_INFO *response_data;
2371 int rc = 0;
2372 int bytes_returned = 0;
2373 __u16 params, byte_count;
2374
2375 cFYI(1, ("In QFSDeviceInfo"));
2376 QFSDeviceRetry:
2377 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2378 (void **) &pSMBr);
2379 if (rc)
2380 return rc;
2381
2382 params = 2; /* level */
2383 pSMB->TotalDataCount = 0;
2384 pSMB->MaxParameterCount = cpu_to_le16(2);
2385 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2386 pSMB->MaxSetupCount = 0;
2387 pSMB->Reserved = 0;
2388 pSMB->Flags = 0;
2389 pSMB->Timeout = 0;
2390 pSMB->Reserved2 = 0;
2391 byte_count = params + 1 /* pad */ ;
2392 pSMB->TotalParameterCount = cpu_to_le16(params);
2393 pSMB->ParameterCount = pSMB->TotalParameterCount;
2394 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2395 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2396
2397 pSMB->DataCount = 0;
2398 pSMB->DataOffset = 0;
2399 pSMB->SetupCount = 1;
2400 pSMB->Reserved3 = 0;
2401 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2402 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
2403 pSMB->hdr.smb_buf_length += byte_count;
2404 pSMB->ByteCount = cpu_to_le16(byte_count);
2405
2406 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2407 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2408 if (rc) {
2409 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
2410 } else { /* decode response */
2411 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
2412 if ((pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO))
2413 || (data_offset > 512))
2414 rc = -EIO; /* bad smb */
2415 else {
2416 response_data =
2417 (FILE_SYSTEM_DEVICE_INFO
2418 *) (((char *) &pSMBr->hdr.Protocol) +
2419 data_offset);
2420 memcpy(&tcon->fsDevInfo, response_data,
2421 sizeof (FILE_SYSTEM_DEVICE_INFO));
2422 }
2423 }
2424 if (pSMB)
2425 cifs_buf_release(pSMB);
2426
2427 if (rc == -EAGAIN)
2428 goto QFSDeviceRetry;
2429
2430 return rc;
2431 }
2432
2433 int
2434 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon,
2435 const struct nls_table *nls_codepage)
2436 {
2437 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
2438 TRANSACTION2_QFSI_REQ *pSMB = NULL;
2439 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
2440 FILE_SYSTEM_UNIX_INFO *response_data;
2441 int rc = 0;
2442 int bytes_returned = 0;
2443 __u16 params, byte_count;
2444
2445 cFYI(1, ("In QFSUnixInfo"));
2446 QFSUnixRetry:
2447 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2448 (void **) &pSMBr);
2449 if (rc)
2450 return rc;
2451
2452 params = 2; /* level */
2453 pSMB->TotalDataCount = 0;
2454 pSMB->DataCount = 0;
2455 pSMB->DataOffset = 0;
2456 pSMB->MaxParameterCount = cpu_to_le16(2);
2457 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
2458 pSMB->MaxSetupCount = 0;
2459 pSMB->Reserved = 0;
2460 pSMB->Flags = 0;
2461 pSMB->Timeout = 0;
2462 pSMB->Reserved2 = 0;
2463 byte_count = params + 1 /* pad */ ;
2464 pSMB->ParameterCount = cpu_to_le16(params);
2465 pSMB->TotalParameterCount = pSMB->ParameterCount;
2466 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
2467 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
2468 pSMB->SetupCount = 1;
2469 pSMB->Reserved3 = 0;
2470 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
2471 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
2472 pSMB->hdr.smb_buf_length += byte_count;
2473 pSMB->ByteCount = cpu_to_le16(byte_count);
2474
2475 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2476 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2477 if (rc) {
2478 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
2479 } else { /* decode response */
2480 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
2481 if ((pSMBr->ByteCount < 13) || (data_offset > 512)) {
2482 rc = -EIO; /* bad smb */
2483 } else {
2484 response_data =
2485 (FILE_SYSTEM_UNIX_INFO
2486 *) (((char *) &pSMBr->hdr.Protocol) +
2487 data_offset);
2488 memcpy(&tcon->fsUnixInfo, response_data,
2489 sizeof (FILE_SYSTEM_UNIX_INFO));
2490 }
2491 }
2492 if (pSMB)
2493 cifs_buf_release(pSMB);
2494
2495 if (rc == -EAGAIN)
2496 goto QFSUnixRetry;
2497
2498
2499 return rc;
2500 }
2501
2502 /* We can not use write of zero bytes trick to
2503 set file size due to need for large file support. Also note that
2504 this SetPathInfo is preferred to SetFileInfo based method in next
2505 routine which is only needed to work around a sharing violation bug
2506 in Samba which this routine can run into */
2507
2508 int
2509 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
2510 __u64 size, int SetAllocation, const struct nls_table *nls_codepage)
2511 {
2512 struct smb_com_transaction2_spi_req *pSMB = NULL;
2513 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2514 struct file_end_of_file_info *parm_data;
2515 int name_len;
2516 int rc = 0;
2517 int bytes_returned = 0;
2518 __u16 params, byte_count, data_count, param_offset, offset;
2519
2520 cFYI(1, ("In SetEOF"));
2521 SetEOFRetry:
2522 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2523 (void **) &pSMBr);
2524 if (rc)
2525 return rc;
2526
2527 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2528 name_len =
2529 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
2530 /* find define for this maxpathcomponent */
2531 , nls_codepage);
2532 name_len++; /* trailing null */
2533 name_len *= 2;
2534 } else { /* BB improve the check for buffer overruns BB */
2535 name_len = strnlen(fileName, 530);
2536 name_len++; /* trailing null */
2537 strncpy(pSMB->FileName, fileName, name_len);
2538 }
2539 params = 6 + name_len;
2540 data_count = sizeof (struct file_end_of_file_info);
2541 pSMB->MaxParameterCount = cpu_to_le16(2);
2542 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2543 pSMB->MaxSetupCount = 0;
2544 pSMB->Reserved = 0;
2545 pSMB->Flags = 0;
2546 pSMB->Timeout = 0;
2547 pSMB->Reserved2 = 0;
2548 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2549 InformationLevel) - 4;
2550 offset = param_offset + params;
2551 if(SetAllocation) {
2552 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2553 pSMB->InformationLevel =
2554 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
2555 else
2556 pSMB->InformationLevel =
2557 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
2558 } else /* Set File Size */ {
2559 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2560 pSMB->InformationLevel =
2561 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
2562 else
2563 pSMB->InformationLevel =
2564 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
2565 }
2566
2567 parm_data =
2568 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
2569 offset);
2570 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2571 pSMB->DataOffset = cpu_to_le16(offset);
2572 pSMB->SetupCount = 1;
2573 pSMB->Reserved3 = 0;
2574 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2575 byte_count = 3 /* pad */ + params + data_count;
2576 pSMB->DataCount = cpu_to_le16(data_count);
2577 pSMB->TotalDataCount = pSMB->DataCount;
2578 pSMB->ParameterCount = cpu_to_le16(params);
2579 pSMB->TotalParameterCount = pSMB->ParameterCount;
2580 pSMB->Reserved4 = 0;
2581 pSMB->hdr.smb_buf_length += byte_count;
2582 parm_data->FileSize = cpu_to_le64(size);
2583 pSMB->ByteCount = cpu_to_le16(byte_count);
2584 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2585 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2586 if (rc) {
2587 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
2588 }
2589
2590 if (pSMB)
2591 cifs_buf_release(pSMB);
2592
2593 if (rc == -EAGAIN)
2594 goto SetEOFRetry;
2595
2596 return rc;
2597 }
2598
2599 int
2600 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
2601 __u16 fid, __u32 pid_of_opener, int SetAllocation)
2602 {
2603 struct smb_com_transaction2_sfi_req *pSMB = NULL;
2604 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2605 char *data_offset;
2606 struct file_end_of_file_info *parm_data;
2607 int rc = 0;
2608 int bytes_returned = 0;
2609 __u16 params, param_offset, offset, byte_count, count;
2610
2611 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
2612 (long long)size));
2613 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2614 (void **) &pSMBr);
2615 if (rc)
2616 return rc;
2617
2618 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
2619 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
2620
2621 params = 6;
2622 pSMB->MaxSetupCount = 0;
2623 pSMB->Reserved = 0;
2624 pSMB->Flags = 0;
2625 pSMB->Timeout = 0;
2626 pSMB->Reserved2 = 0;
2627 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2628 offset = param_offset + params;
2629
2630 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2631
2632 count = sizeof(struct file_end_of_file_info);
2633 pSMB->MaxParameterCount = cpu_to_le16(2);
2634 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
2635 pSMB->SetupCount = 1;
2636 pSMB->Reserved3 = 0;
2637 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2638 byte_count = 3 /* pad */ + params + count;
2639 pSMB->DataCount = cpu_to_le16(count);
2640 pSMB->ParameterCount = cpu_to_le16(params);
2641 pSMB->TotalDataCount = pSMB->DataCount;
2642 pSMB->TotalParameterCount = pSMB->ParameterCount;
2643 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2644 parm_data =
2645 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
2646 offset);
2647 pSMB->DataOffset = cpu_to_le16(offset);
2648 parm_data->FileSize = cpu_to_le64(size);
2649 pSMB->Fid = fid;
2650 if(SetAllocation) {
2651 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2652 pSMB->InformationLevel =
2653 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
2654 else
2655 pSMB->InformationLevel =
2656 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
2657 } else /* Set File Size */ {
2658 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2659 pSMB->InformationLevel =
2660 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
2661 else
2662 pSMB->InformationLevel =
2663 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
2664 }
2665 pSMB->Reserved4 = 0;
2666 pSMB->hdr.smb_buf_length += byte_count;
2667 pSMB->ByteCount = cpu_to_le16(byte_count);
2668 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2669 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2670 if (rc) {
2671 cFYI(1,
2672 ("Send error in SetFileInfo (SetFileSize) = %d",
2673 rc));
2674 }
2675
2676 if (pSMB)
2677 cifs_buf_release(pSMB);
2678
2679 /* Note: On -EAGAIN error only caller can retry on handle based calls
2680 since file handle passed in no longer valid */
2681
2682 return rc;
2683 }
2684
2685 int
2686 CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
2687 const FILE_BASIC_INFO * data,
2688 const struct nls_table *nls_codepage)
2689 {
2690 TRANSACTION2_SPI_REQ *pSMB = NULL;
2691 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2692 int name_len;
2693 int rc = 0;
2694 int bytes_returned = 0;
2695 char *data_offset;
2696 __u16 params, param_offset, offset, byte_count, count;
2697
2698 cFYI(1, ("In SetTimes"));
2699
2700 SetTimesRetry:
2701 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2702 (void **) &pSMBr);
2703 if (rc)
2704 return rc;
2705
2706 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2707 name_len =
2708 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
2709 /* find define for this maxpathcomponent */
2710 , nls_codepage);
2711 name_len++; /* trailing null */
2712 name_len *= 2;
2713 } else { /* BB improve the check for buffer overruns BB */
2714 name_len = strnlen(fileName, 530);
2715 name_len++; /* trailing null */
2716 strncpy(pSMB->FileName, fileName, name_len);
2717 }
2718
2719 params = 6 + name_len;
2720 count = sizeof (FILE_BASIC_INFO);
2721 pSMB->MaxParameterCount = cpu_to_le16(2);
2722 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2723 pSMB->MaxSetupCount = 0;
2724 pSMB->Reserved = 0;
2725 pSMB->Flags = 0;
2726 pSMB->Timeout = 0;
2727 pSMB->Reserved2 = 0;
2728 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2729 InformationLevel) - 4;
2730 offset = param_offset + params;
2731 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2732 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2733 pSMB->DataOffset = cpu_to_le16(offset);
2734 pSMB->SetupCount = 1;
2735 pSMB->Reserved3 = 0;
2736 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2737 byte_count = 3 /* pad */ + params + count;
2738
2739 pSMB->DataCount = cpu_to_le16(count);
2740 pSMB->ParameterCount = cpu_to_le16(params);
2741 pSMB->TotalDataCount = pSMB->DataCount;
2742 pSMB->TotalParameterCount = pSMB->ParameterCount;
2743 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2744 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
2745 else
2746 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
2747 pSMB->Reserved4 = 0;
2748 pSMB->hdr.smb_buf_length += byte_count;
2749 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
2750 pSMB->ByteCount = cpu_to_le16(byte_count);
2751 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2752 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2753 if (rc) {
2754 cFYI(1, ("SetPathInfo (times) returned %d", rc));
2755 }
2756
2757 if (pSMB)
2758 cifs_buf_release(pSMB);
2759
2760 if (rc == -EAGAIN)
2761 goto SetTimesRetry;
2762
2763 return rc;
2764 }
2765
2766 int
2767 CIFSSMBSetTimesLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
2768 FILE_INFO_STANDARD * data, const struct nls_table *nls_codepage)
2769 {
2770 TRANSACTION2_SPI_REQ *pSMB = NULL;
2771 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2772 int name_len;
2773 int rc = 0;
2774 int bytes_returned = 0;
2775 char *data_offset;
2776 __u16 params, param_offset, count, offset, byte_count;
2777
2778 cFYI(1, ("In SetTimesLegacy"));
2779
2780 SetTimesRetryLegacy:
2781 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2782 (void **) &pSMBr);
2783 if (rc)
2784 return rc;
2785
2786 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2787 name_len =
2788 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
2789 /* find define for this maxpathcomponent */
2790 , nls_codepage);
2791 name_len++; /* trailing null */
2792 name_len *= 2;
2793 } else { /* BB improve the check for buffer overruns BB */
2794 name_len = strnlen(fileName, 530);
2795 name_len++; /* trailing null */
2796 strncpy(pSMB->FileName, fileName, name_len);
2797 }
2798 /* BB fixme - we have to map to FILE_STANDARD_INFO (level 1 info
2799 in parent function, from the better and ususal FILE_BASIC_INFO */
2800 params = 6 + name_len;
2801 count = sizeof (FILE_INFO_STANDARD);
2802 pSMB->MaxParameterCount = cpu_to_le16(2);
2803 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2804 pSMB->MaxSetupCount = 0;
2805 pSMB->Reserved = 0;
2806 pSMB->Flags = 0;
2807 pSMB->Timeout = 0;
2808 pSMB->Reserved2 = 0;
2809 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2810 InformationLevel) - 4;
2811 offset = param_offset + params;
2812 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2813 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2814 pSMB->DataOffset = cpu_to_le16(offset);
2815 pSMB->SetupCount = 1;
2816 pSMB->Reserved3 = 0;
2817 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2818 byte_count = 3 /* pad */ + params + count;
2819
2820 pSMB->DataCount = cpu_to_le16(count);
2821 pSMB->ParameterCount = cpu_to_le16(params);
2822 pSMB->TotalDataCount = pSMB->DataCount;
2823 pSMB->TotalParameterCount = pSMB->ParameterCount;
2824 /* I doubt that passthrough levels apply to this old
2825 preNT info level */
2826 /* if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
2827 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
2828 else*/
2829 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
2830 pSMB->Reserved4 = 0;
2831 pSMB->hdr.smb_buf_length += byte_count;
2832 memcpy(data_offset, data, sizeof (FILE_INFO_STANDARD));
2833 pSMB->ByteCount = cpu_to_le16(byte_count);
2834 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2835 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2836 if (rc) {
2837 cFYI(1, ("SetPathInfo (times legacy) returned %d", rc));
2838 }
2839
2840 if (pSMB)
2841 cifs_buf_release(pSMB);
2842
2843 if (rc == -EAGAIN)
2844 goto SetTimesRetryLegacy;
2845
2846 return rc;
2847 }
2848
2849 int
2850 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
2851 char *fileName, __u64 mode, __u64 uid, __u64 gid,
2852 dev_t device, const struct nls_table *nls_codepage)
2853 {
2854 TRANSACTION2_SPI_REQ *pSMB = NULL;
2855 TRANSACTION2_SPI_RSP *pSMBr = NULL;
2856 int name_len;
2857 int rc = 0;
2858 int bytes_returned = 0;
2859 FILE_UNIX_BASIC_INFO *data_offset;
2860 __u16 params, param_offset, offset, count, byte_count;
2861
2862 cFYI(1, ("In SetUID/GID/Mode"));
2863 setPermsRetry:
2864 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2865 (void **) &pSMBr);
2866 if (rc)
2867 return rc;
2868
2869 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2870 name_len =
2871 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
2872 /* find define for this maxpathcomponent */
2873 , nls_codepage);
2874 name_len++; /* trailing null */
2875 name_len *= 2;
2876 } else { /* BB improve the check for buffer overruns BB */
2877 name_len = strnlen(fileName, 530);
2878 name_len++; /* trailing null */
2879 strncpy(pSMB->FileName, fileName, name_len);
2880 }
2881
2882 params = 6 + name_len;
2883 count = sizeof (FILE_UNIX_BASIC_INFO);
2884 pSMB->MaxParameterCount = cpu_to_le16(2);
2885 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
2886 pSMB->MaxSetupCount = 0;
2887 pSMB->Reserved = 0;
2888 pSMB->Flags = 0;
2889 pSMB->Timeout = 0;
2890 pSMB->Reserved2 = 0;
2891 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2892 InformationLevel) - 4;
2893 offset = param_offset + params;
2894 data_offset =
2895 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
2896 offset);
2897 pSMB->DataOffset = cpu_to_le16(offset);
2898 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2899 pSMB->SetupCount = 1;
2900 pSMB->Reserved3 = 0;
2901 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2902 byte_count = 3 /* pad */ + params + count;
2903 pSMB->ParameterCount = cpu_to_le16(params);
2904 pSMB->DataCount = cpu_to_le16(count);
2905 pSMB->TotalParameterCount = pSMB->ParameterCount;
2906 pSMB->TotalDataCount = pSMB->DataCount;
2907 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
2908 pSMB->Reserved4 = 0;
2909 pSMB->hdr.smb_buf_length += byte_count;
2910 data_offset->Uid = cpu_to_le64(uid);
2911 data_offset->Gid = cpu_to_le64(gid);
2912 /* better to leave device as zero when it is */
2913 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
2914 data_offset->DevMinor = cpu_to_le64(MINOR(device));
2915 data_offset->Permissions = cpu_to_le64(mode);
2916
2917 if(S_ISREG(mode))
2918 data_offset->Type = cpu_to_le32(UNIX_FILE);
2919 else if(S_ISDIR(mode))
2920 data_offset->Type = cpu_to_le32(UNIX_DIR);
2921 else if(S_ISLNK(mode))
2922 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
2923 else if(S_ISCHR(mode))
2924 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
2925 else if(S_ISBLK(mode))
2926 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
2927 else if(S_ISFIFO(mode))
2928 data_offset->Type = cpu_to_le32(UNIX_FIFO);
2929 else if(S_ISSOCK(mode))
2930 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
2931
2932
2933 pSMB->ByteCount = cpu_to_le16(byte_count);
2934 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2935 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2936 if (rc) {
2937 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
2938 }
2939
2940 if (pSMB)
2941 cifs_buf_release(pSMB);
2942 if (rc == -EAGAIN)
2943 goto setPermsRetry;
2944 return rc;
2945 }
2946
2947 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
2948 const int notify_subdirs, const __u16 netfid,
2949 __u32 filter, const struct nls_table *nls_codepage)
2950 {
2951 int rc = 0;
2952 struct smb_com_transaction_change_notify_req * pSMB = NULL;
2953 struct smb_com_transaction_change_notify_rsp * pSMBr = NULL;
2954 int bytes_returned;
2955
2956 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
2957 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2958 (void **) &pSMBr);
2959 if (rc)
2960 return rc;
2961
2962 pSMB->TotalParameterCount = 0 ;
2963 pSMB->TotalDataCount = 0;
2964 pSMB->MaxParameterCount = cpu_to_le32(2);
2965 /* BB find exact data count max from sess structure BB */
2966 pSMB->MaxDataCount = 0; /* same in little endian or be */
2967 pSMB->MaxSetupCount = 4;
2968 pSMB->Reserved = 0;
2969 pSMB->ParameterOffset = 0;
2970 pSMB->DataCount = 0;
2971 pSMB->DataOffset = 0;
2972 pSMB->SetupCount = 4; /* single byte does not need le conversion */
2973 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
2974 pSMB->ParameterCount = pSMB->TotalParameterCount;
2975 if(notify_subdirs)
2976 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
2977 pSMB->Reserved2 = 0;
2978 pSMB->CompletionFilter = cpu_to_le32(filter);
2979 pSMB->Fid = netfid; /* file handle always le */
2980 pSMB->ByteCount = 0;
2981
2982 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2983 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2984 if (rc) {
2985 cFYI(1, ("Error in Notify = %d", rc));
2986 }
2987 if (pSMB)
2988 cifs_buf_release(pSMB);
2989 /* if (rc == -EAGAIN)
2990 goto NotifyRetry; */
2991 return rc;
2992 }
2993 #ifdef CONFIG_CIFS_XATTR
2994 ssize_t
2995 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
2996 const unsigned char *searchName,
2997 char * EAData, size_t buf_size,
2998 const struct nls_table *nls_codepage)
2999 {
3000 /* BB assumes one setup word */
3001 TRANSACTION2_QPI_REQ *pSMB = NULL;
3002 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3003 int rc = 0;
3004 int bytes_returned;
3005 int name_len;
3006 struct fea * temp_fea;
3007 char * temp_ptr;
3008 __u16 params, byte_count;
3009
3010 cFYI(1, ("In Query All EAs path %s", searchName));
3011 QAllEAsRetry:
3012 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3013 (void **) &pSMBr);
3014 if (rc)
3015 return rc;
3016
3017 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3018 name_len =
3019 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
3020 /* find define for this maxpathcomponent */
3021 , nls_codepage);
3022 name_len++; /* trailing null */
3023 name_len *= 2;
3024 } else { /* BB improve the check for buffer overruns BB */
3025 name_len = strnlen(searchName, 530);
3026 name_len++; /* trailing null */
3027 strncpy(pSMB->FileName, searchName, name_len);
3028 }
3029
3030 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3031 pSMB->TotalDataCount = 0;
3032 pSMB->MaxParameterCount = cpu_to_le16(2);
3033 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3034 pSMB->MaxSetupCount = 0;
3035 pSMB->Reserved = 0;
3036 pSMB->Flags = 0;
3037 pSMB->Timeout = 0;
3038 pSMB->Reserved2 = 0;
3039 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3040 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3041 pSMB->DataCount = 0;
3042 pSMB->DataOffset = 0;
3043 pSMB->SetupCount = 1;
3044 pSMB->Reserved3 = 0;
3045 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3046 byte_count = params + 1 /* pad */ ;
3047 pSMB->TotalParameterCount = cpu_to_le16(params);
3048 pSMB->ParameterCount = pSMB->TotalParameterCount;
3049 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3050 pSMB->Reserved4 = 0;
3051 pSMB->hdr.smb_buf_length += byte_count;
3052 pSMB->ByteCount = cpu_to_le16(byte_count);
3053
3054 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3055 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3056 if (rc) {
3057 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
3058 } else { /* decode response */
3059 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
3060 /* BB also check enough total bytes returned */
3061 /* BB we need to improve the validity checking
3062 of these trans2 responses */
3063 if ((pSMBr->ByteCount < 4) || (data_offset > 512))
3064 rc = -EIO; /* bad smb */
3065 /* else if (pFindData){
3066 memcpy((char *) pFindData,
3067 (char *) &pSMBr->hdr.Protocol +
3068 data_offset, kl);
3069 }*/ else {
3070 /* check that length of list is not more than bcc */
3071 /* check that each entry does not go beyond length
3072 of list */
3073 /* check that each element of each entry does not
3074 go beyond end of list */
3075 struct fealist * ea_response_data;
3076 rc = 0;
3077 /* validate_trans2_offsets() */
3078 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
3079 ea_response_data = (struct fealist *)
3080 (((char *) &pSMBr->hdr.Protocol) +
3081 data_offset);
3082 name_len = le32_to_cpu(ea_response_data->list_len);
3083 cFYI(1,("ea length %d", name_len));
3084 if(name_len <= 8) {
3085 /* returned EA size zeroed at top of function */
3086 cFYI(1,("empty EA list returned from server"));
3087 } else {
3088 /* account for ea list len */
3089 name_len -= 4;
3090 temp_fea = ea_response_data->list;
3091 temp_ptr = (char *)temp_fea;
3092 while(name_len > 0) {
3093 __u16 value_len;
3094 name_len -= 4;
3095 temp_ptr += 4;
3096 rc += temp_fea->name_len;
3097 /* account for prefix user. and trailing null */
3098 rc = rc + 5 + 1;
3099 if(rc<(int)buf_size) {
3100 memcpy(EAData,"user.",5);
3101 EAData+=5;
3102 memcpy(EAData,temp_ptr,temp_fea->name_len);
3103 EAData+=temp_fea->name_len;
3104 /* null terminate name */
3105 *EAData = 0;
3106 EAData = EAData + 1;
3107 } else if(buf_size == 0) {
3108 /* skip copy - calc size only */
3109 } else {
3110 /* stop before overrun buffer */
3111 rc = -ERANGE;
3112 break;
3113 }
3114 name_len -= temp_fea->name_len;
3115 temp_ptr += temp_fea->name_len;
3116 /* account for trailing null */
3117 name_len--;
3118 temp_ptr++;
3119 value_len = le16_to_cpu(temp_fea->value_len);
3120 name_len -= value_len;
3121 temp_ptr += value_len;
3122 /* BB check that temp_ptr is still within smb BB*/
3123 /* no trailing null to account for in value len */
3124 /* go on to next EA */
3125 temp_fea = (struct fea *)temp_ptr;
3126 }
3127 }
3128 }
3129 }
3130 if (pSMB)
3131 cifs_buf_release(pSMB);
3132 if (rc == -EAGAIN)
3133 goto QAllEAsRetry;
3134
3135 return (ssize_t)rc;
3136 }
3137
3138 ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
3139 const unsigned char * searchName,const unsigned char * ea_name,
3140 unsigned char * ea_value, size_t buf_size,
3141 const struct nls_table *nls_codepage)
3142 {
3143 TRANSACTION2_QPI_REQ *pSMB = NULL;
3144 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3145 int rc = 0;
3146 int bytes_returned;
3147 int name_len;
3148 struct fea * temp_fea;
3149 char * temp_ptr;
3150 __u16 params, byte_count;
3151
3152 cFYI(1, ("In Query EA path %s", searchName));
3153 QEARetry:
3154 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3155 (void **) &pSMBr);
3156 if (rc)
3157 return rc;
3158
3159 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3160 name_len =
3161 cifs_strtoUCS((wchar_t *) pSMB->FileName, searchName, 530
3162 /* find define for this maxpathcomponent */
3163 , nls_codepage);
3164 name_len++; /* trailing null */
3165 name_len *= 2;
3166 } else { /* BB improve the check for buffer overruns BB */
3167 name_len = strnlen(searchName, 530);
3168 name_len++; /* trailing null */
3169 strncpy(pSMB->FileName, searchName, name_len);
3170 }
3171
3172 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3173 pSMB->TotalDataCount = 0;
3174 pSMB->MaxParameterCount = cpu_to_le16(2);
3175 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3176 pSMB->MaxSetupCount = 0;
3177 pSMB->Reserved = 0;
3178 pSMB->Flags = 0;
3179 pSMB->Timeout = 0;
3180 pSMB->Reserved2 = 0;
3181 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3182 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3183 pSMB->DataCount = 0;
3184 pSMB->DataOffset = 0;
3185 pSMB->SetupCount = 1;
3186 pSMB->Reserved3 = 0;
3187 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3188 byte_count = params + 1 /* pad */ ;
3189 pSMB->TotalParameterCount = cpu_to_le16(params);
3190 pSMB->ParameterCount = pSMB->TotalParameterCount;
3191 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
3192 pSMB->Reserved4 = 0;
3193 pSMB->hdr.smb_buf_length += byte_count;
3194 pSMB->ByteCount = cpu_to_le16(byte_count);
3195
3196 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3197 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3198 if (rc) {
3199 cFYI(1, ("Send error in Query EA = %d", rc));
3200 } else { /* decode response */
3201 __u16 data_offset = le16_to_cpu(pSMBr->DataOffset);
3202 /* BB also check enough total bytes returned */
3203 /* BB we need to improve the validity checking
3204 of these trans2 responses */
3205 if ((pSMBr->ByteCount < 4) || (data_offset > 512))
3206 rc = -EIO; /* bad smb */
3207 /* else if (pFindData){
3208 memcpy((char *) pFindData,
3209 (char *) &pSMBr->hdr.Protocol +
3210 data_offset, kl);
3211 }*/ else {
3212 /* check that length of list is not more than bcc */
3213 /* check that each entry does not go beyond length
3214 of list */
3215 /* check that each element of each entry does not
3216 go beyond end of list */
3217 struct fealist * ea_response_data;
3218 rc = -ENOENT;
3219 /* validate_trans2_offsets() */
3220 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
3221 ea_response_data = (struct fealist *)
3222 (((char *) &pSMBr->hdr.Protocol) +
3223 data_offset);
3224 name_len = le32_to_cpu(ea_response_data->list_len);
3225 cFYI(1,("ea length %d", name_len));
3226 if(name_len <= 8) {
3227 /* returned EA size zeroed at top of function */
3228 cFYI(1,("empty EA list returned from server"));
3229 } else {
3230 /* account for ea list len */
3231 name_len -= 4;
3232 temp_fea = ea_response_data->list;
3233 temp_ptr = (char *)temp_fea;
3234 /* loop through checking if we have a matching
3235 name and then return the associated value */
3236 while(name_len > 0) {
3237 __u16 value_len;
3238 name_len -= 4;
3239 temp_ptr += 4;
3240 value_len = le16_to_cpu(temp_fea->value_len);
3241 /* BB validate that value_len falls within SMB,
3242 even though maximum for name_len is 255 */
3243 if(memcmp(temp_fea->name,ea_name,
3244 temp_fea->name_len) == 0) {
3245 /* found a match */
3246 rc = value_len;
3247 /* account for prefix user. and trailing null */
3248 if(rc<=(int)buf_size) {
3249 memcpy(ea_value,
3250 temp_fea->name+temp_fea->name_len+1,
3251 rc);
3252 /* ea values, unlike ea names,
3253 are not null terminated */
3254 } else if(buf_size == 0) {
3255 /* skip copy - calc size only */
3256 } else {
3257 /* stop before overrun buffer */
3258 rc = -ERANGE;
3259 }
3260 break;
3261 }
3262 name_len -= temp_fea->name_len;
3263 temp_ptr += temp_fea->name_len;
3264 /* account for trailing null */
3265 name_len--;
3266 temp_ptr++;
3267 name_len -= value_len;
3268 temp_ptr += value_len;
3269 /* no trailing null to account for in value len */
3270 /* go on to next EA */
3271 temp_fea = (struct fea *)temp_ptr;
3272 }
3273 }
3274 }
3275 }
3276 if (pSMB)
3277 cifs_buf_release(pSMB);
3278 if (rc == -EAGAIN)
3279 goto QEARetry;
3280
3281 return (ssize_t)rc;
3282 }
3283
3284 int
3285 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
3286 const char * ea_name, const void * ea_value,
3287 const __u16 ea_value_len, const struct nls_table *nls_codepage)
3288 {
3289 struct smb_com_transaction2_spi_req *pSMB = NULL;
3290 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3291 struct fealist *parm_data;
3292 int name_len;
3293 int rc = 0;
3294 int bytes_returned = 0;
3295 __u16 params, param_offset, byte_count, offset, count;
3296
3297 cFYI(1, ("In SetEA"));
3298 SetEARetry:
3299 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3300 (void **) &pSMBr);
3301 if (rc)
3302 return rc;
3303
3304 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3305 name_len =
3306 cifs_strtoUCS((wchar_t *) pSMB->FileName, fileName, 530
3307 /* find define for this maxpathcomponent */
3308 , nls_codepage);
3309 name_len++; /* trailing null */
3310 name_len *= 2;
3311 } else { /* BB improve the check for buffer overruns BB */
3312 name_len = strnlen(fileName, 530);
3313 name_len++; /* trailing null */
3314 strncpy(pSMB->FileName, fileName, name_len);
3315 }
3316
3317 params = 6 + name_len;
3318
3319 /* done calculating parms using name_len of file name,
3320 now use name_len to calculate length of ea name
3321 we are going to create in the inode xattrs */
3322 if(ea_name == NULL)
3323 name_len = 0;
3324 else
3325 name_len = strnlen(ea_name,255);
3326
3327 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
3328 pSMB->MaxParameterCount = cpu_to_le16(2);
3329 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
3330 pSMB->MaxSetupCount = 0;
3331 pSMB->Reserved = 0;
3332 pSMB->Flags = 0;
3333 pSMB->Timeout = 0;
3334 pSMB->Reserved2 = 0;
3335 param_offset = offsetof(struct smb_com_transaction2_spi_req,
3336 InformationLevel) - 4;
3337 offset = param_offset + params;
3338 pSMB->InformationLevel =
3339 cpu_to_le16(SMB_SET_FILE_EA);
3340
3341 parm_data =
3342 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
3343 offset);
3344 pSMB->ParameterOffset = cpu_to_le16(param_offset);
3345 pSMB->DataOffset = cpu_to_le16(offset);
3346 pSMB->SetupCount = 1;
3347 pSMB->Reserved3 = 0;
3348 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3349 byte_count = 3 /* pad */ + params + count;
3350 pSMB->DataCount = cpu_to_le16(count);
3351 parm_data->list_len = cpu_to_le32(count);
3352 parm_data->list[0].EA_flags = 0;
3353 /* we checked above that name len is less than 255 */
3354 parm_data->list[0].name_len = (__u8)name_len;;
3355 /* EA names are always ASCII */
3356 strncpy(parm_data->list[0].name,ea_name,name_len);
3357 parm_data->list[0].name[name_len] = 0;
3358 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
3359 /* caller ensures that ea_value_len is less than 64K but
3360 we need to ensure that it fits within the smb */
3361
3362 /*BB add length check that it would fit in negotiated SMB buffer size BB */
3363 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
3364 if(ea_value_len)
3365 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
3366
3367 pSMB->TotalDataCount = pSMB->DataCount;
3368 pSMB->ParameterCount = cpu_to_le16(params);
3369 pSMB->TotalParameterCount = pSMB->ParameterCount;
3370 pSMB->Reserved4 = 0;
3371 pSMB->hdr.smb_buf_length += byte_count;
3372 pSMB->ByteCount = cpu_to_le16(byte_count);
3373 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3374 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3375 if (rc) {
3376 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
3377 }
3378
3379 if (pSMB)
3380 cifs_buf_release(pSMB);
3381
3382 if (rc == -EAGAIN)
3383 goto SetEARetry;
3384
3385 return rc;
3386 }
3387
3388 #endif
MOXA 2.6.9 from sdlinux-moxaart.tgz