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