?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] v850: call init_page_count() instead of set_page_count()
[linux-2.6/verdex.git] / fs / cifs / cifssmb.c
blob19678c575dfc4bcc786d158a20f56a450caccec1
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 == 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 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1464 (struct smb_hdr *) pSMBr, &bytes_returned, timeout);
1465 cifs_stats_inc(&tcon->num_locks);
1466 if (rc) {
1467 cFYI(1, ("Send error in Lock = %d", rc));
1468 }
1469 cifs_small_buf_release(pSMB);
1470
1471 /* Note: On -EAGAIN error only caller can retry on handle based calls
1472 since file handle passed in no longer valid */
1473 return rc;
1474 }
1475
1476 int
1477 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
1478 const __u16 smb_file_id, const int get_flag, const __u64 len,
1479 struct file_lock *pLockData, const __u16 lock_type,
1480 const int waitFlag)
1481 {
1482 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1483 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1484 char *data_offset;
1485 struct cifs_posix_lock *parm_data;
1486 int rc = 0;
1487 int bytes_returned = 0;
1488 __u16 params, param_offset, offset, byte_count, count;
1489
1490 cFYI(1, ("Posix Lock"));
1491
1492 if(pLockData == NULL)
1493 return EINVAL;
1494
1495 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1496
1497 if (rc)
1498 return rc;
1499
1500 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1501
1502 params = 6;
1503 pSMB->MaxSetupCount = 0;
1504 pSMB->Reserved = 0;
1505 pSMB->Flags = 0;
1506 pSMB->Timeout = 0;
1507 pSMB->Reserved2 = 0;
1508 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1509 offset = param_offset + params;
1510
1511 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1512
1513 count = sizeof(struct cifs_posix_lock);
1514 pSMB->MaxParameterCount = cpu_to_le16(2);
1515 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1516 pSMB->SetupCount = 1;
1517 pSMB->Reserved3 = 0;
1518 if(get_flag)
1519 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
1520 else
1521 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1522 byte_count = 3 /* pad */ + params + count;
1523 pSMB->DataCount = cpu_to_le16(count);
1524 pSMB->ParameterCount = cpu_to_le16(params);
1525 pSMB->TotalDataCount = pSMB->DataCount;
1526 pSMB->TotalParameterCount = pSMB->ParameterCount;
1527 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1528 parm_data = (struct cifs_posix_lock *)
1529 (((char *) &pSMB->hdr.Protocol) + offset);
1530
1531 parm_data->lock_type = cpu_to_le16(lock_type);
1532 if(waitFlag)
1533 parm_data->lock_flags = cpu_to_le16(1);
1534 parm_data->pid = cpu_to_le32(current->tgid);
1535 parm_data->start = cpu_to_le64(pLockData->fl_start);
1536 parm_data->length = cpu_to_le64(len); /* normalize negative numbers */
1537
1538 pSMB->DataOffset = cpu_to_le16(offset);
1539 pSMB->Fid = smb_file_id;
1540 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
1541 pSMB->Reserved4 = 0;
1542 pSMB->hdr.smb_buf_length += byte_count;
1543 pSMB->ByteCount = cpu_to_le16(byte_count);
1544 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1545 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1546 if (rc) {
1547 cFYI(1, ("Send error in Posix Lock = %d", rc));
1548 } else if (get_flag) {
1549 /* lock structure can be returned on get */
1550 __u16 data_offset;
1551 __u16 data_count;
1552 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1553
1554 if (rc || (pSMBr->ByteCount < sizeof(struct cifs_posix_lock))) {
1555 rc = -EIO; /* bad smb */
1556 goto plk_err_exit;
1557 }
1558 if(pLockData == NULL) {
1559 rc = -EINVAL;
1560 goto plk_err_exit;
1561 }
1562 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1563 data_count = le16_to_cpu(pSMBr->t2.DataCount);
1564 if(data_count < sizeof(struct cifs_posix_lock)) {
1565 rc = -EIO;
1566 goto plk_err_exit;
1567 }
1568 parm_data = (struct cifs_posix_lock *)
1569 ((char *)&pSMBr->hdr.Protocol + data_offset);
1570 if(parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
1571 pLockData->fl_type = F_UNLCK;
1572 }
1573
1574 plk_err_exit:
1575 if (pSMB)
1576 cifs_small_buf_release(pSMB);
1577
1578 /* Note: On -EAGAIN error only caller can retry on handle based calls
1579 since file handle passed in no longer valid */
1580
1581 return rc;
1582 }
1583
1584
1585 int
1586 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1587 {
1588 int rc = 0;
1589 CLOSE_REQ *pSMB = NULL;
1590 CLOSE_RSP *pSMBr = NULL;
1591 int bytes_returned;
1592 cFYI(1, ("In CIFSSMBClose"));
1593
1594 /* do not retry on dead session on close */
1595 rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1596 if(rc == -EAGAIN)
1597 return 0;
1598 if (rc)
1599 return rc;
1600
1601 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
1602
1603 pSMB->FileID = (__u16) smb_file_id;
1604 pSMB->LastWriteTime = 0;
1605 pSMB->ByteCount = 0;
1606 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1607 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1608 cifs_stats_inc(&tcon->num_closes);
1609 if (rc) {
1610 if(rc!=-EINTR) {
1611 /* EINTR is expected when user ctl-c to kill app */
1612 cERROR(1, ("Send error in Close = %d", rc));
1613 }
1614 }
1615
1616 cifs_small_buf_release(pSMB);
1617
1618 /* Since session is dead, file will be closed on server already */
1619 if(rc == -EAGAIN)
1620 rc = 0;
1621
1622 return rc;
1623 }
1624
1625 int
1626 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1627 const char *fromName, const char *toName,
1628 const struct nls_table *nls_codepage, int remap)
1629 {
1630 int rc = 0;
1631 RENAME_REQ *pSMB = NULL;
1632 RENAME_RSP *pSMBr = NULL;
1633 int bytes_returned;
1634 int name_len, name_len2;
1635 __u16 count;
1636
1637 cFYI(1, ("In CIFSSMBRename"));
1638 renameRetry:
1639 rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1640 (void **) &pSMBr);
1641 if (rc)
1642 return rc;
1643
1644 pSMB->BufferFormat = 0x04;
1645 pSMB->SearchAttributes =
1646 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1647 ATTR_DIRECTORY);
1648
1649 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1650 name_len =
1651 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1652 PATH_MAX, nls_codepage, remap);
1653 name_len++; /* trailing null */
1654 name_len *= 2;
1655 pSMB->OldFileName[name_len] = 0x04; /* pad */
1656 /* protocol requires ASCII signature byte on Unicode string */
1657 pSMB->OldFileName[name_len + 1] = 0x00;
1658 name_len2 =
1659 cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1660 toName, PATH_MAX, nls_codepage, remap);
1661 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1662 name_len2 *= 2; /* convert to bytes */
1663 } else { /* BB improve the check for buffer overruns BB */
1664 name_len = strnlen(fromName, PATH_MAX);
1665 name_len++; /* trailing null */
1666 strncpy(pSMB->OldFileName, fromName, name_len);
1667 name_len2 = strnlen(toName, PATH_MAX);
1668 name_len2++; /* trailing null */
1669 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1670 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1671 name_len2++; /* trailing null */
1672 name_len2++; /* signature byte */
1673 }
1674
1675 count = 1 /* 1st signature byte */ + name_len + name_len2;
1676 pSMB->hdr.smb_buf_length += count;
1677 pSMB->ByteCount = cpu_to_le16(count);
1678
1679 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1680 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1681 cifs_stats_inc(&tcon->num_renames);
1682 if (rc) {
1683 cFYI(1, ("Send error in rename = %d", rc));
1684 }
1685
1686 cifs_buf_release(pSMB);
1687
1688 if (rc == -EAGAIN)
1689 goto renameRetry;
1690
1691 return rc;
1692 }
1693
1694 int CIFSSMBRenameOpenFile(const int xid,struct cifsTconInfo *pTcon,
1695 int netfid, char * target_name,
1696 const struct nls_table * nls_codepage, int remap)
1697 {
1698 struct smb_com_transaction2_sfi_req *pSMB = NULL;
1699 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1700 struct set_file_rename * rename_info;
1701 char *data_offset;
1702 char dummy_string[30];
1703 int rc = 0;
1704 int bytes_returned = 0;
1705 int len_of_str;
1706 __u16 params, param_offset, offset, count, byte_count;
1707
1708 cFYI(1, ("Rename to File by handle"));
1709 rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
1710 (void **) &pSMBr);
1711 if (rc)
1712 return rc;
1713
1714 params = 6;
1715 pSMB->MaxSetupCount = 0;
1716 pSMB->Reserved = 0;
1717 pSMB->Flags = 0;
1718 pSMB->Timeout = 0;
1719 pSMB->Reserved2 = 0;
1720 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1721 offset = param_offset + params;
1722
1723 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1724 rename_info = (struct set_file_rename *) data_offset;
1725 pSMB->MaxParameterCount = cpu_to_le16(2);
1726 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
1727 pSMB->SetupCount = 1;
1728 pSMB->Reserved3 = 0;
1729 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1730 byte_count = 3 /* pad */ + params;
1731 pSMB->ParameterCount = cpu_to_le16(params);
1732 pSMB->TotalParameterCount = pSMB->ParameterCount;
1733 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1734 pSMB->DataOffset = cpu_to_le16(offset);
1735 /* construct random name ".cifs_tmp<inodenum><mid>" */
1736 rename_info->overwrite = cpu_to_le32(1);
1737 rename_info->root_fid = 0;
1738 /* unicode only call */
1739 if(target_name == NULL) {
1740 sprintf(dummy_string,"cifs%x",pSMB->hdr.Mid);
1741 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1742 dummy_string, 24, nls_codepage, remap);
1743 } else {
1744 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
1745 target_name, PATH_MAX, nls_codepage, remap);
1746 }
1747 rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
1748 count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
1749 byte_count += count;
1750 pSMB->DataCount = cpu_to_le16(count);
1751 pSMB->TotalDataCount = pSMB->DataCount;
1752 pSMB->Fid = netfid;
1753 pSMB->InformationLevel =
1754 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
1755 pSMB->Reserved4 = 0;
1756 pSMB->hdr.smb_buf_length += byte_count;
1757 pSMB->ByteCount = cpu_to_le16(byte_count);
1758 rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
1759 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1760 cifs_stats_inc(&pTcon->num_t2renames);
1761 if (rc) {
1762 cFYI(1,("Send error in Rename (by file handle) = %d", rc));
1763 }
1764
1765 cifs_buf_release(pSMB);
1766
1767 /* Note: On -EAGAIN error only caller can retry on handle based calls
1768 since file handle passed in no longer valid */
1769
1770 return rc;
1771 }
1772
1773 int
1774 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char * fromName,
1775 const __u16 target_tid, const char *toName, const int flags,
1776 const struct nls_table *nls_codepage, int remap)
1777 {
1778 int rc = 0;
1779 COPY_REQ *pSMB = NULL;
1780 COPY_RSP *pSMBr = NULL;
1781 int bytes_returned;
1782 int name_len, name_len2;
1783 __u16 count;
1784
1785 cFYI(1, ("In CIFSSMBCopy"));
1786 copyRetry:
1787 rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
1788 (void **) &pSMBr);
1789 if (rc)
1790 return rc;
1791
1792 pSMB->BufferFormat = 0x04;
1793 pSMB->Tid2 = target_tid;
1794
1795 pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
1796
1797 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1798 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
1799 fromName, PATH_MAX, nls_codepage,
1800 remap);
1801 name_len++; /* trailing null */
1802 name_len *= 2;
1803 pSMB->OldFileName[name_len] = 0x04; /* pad */
1804 /* protocol requires ASCII signature byte on Unicode string */
1805 pSMB->OldFileName[name_len + 1] = 0x00;
1806 name_len2 = cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
1807 toName, PATH_MAX, nls_codepage, remap);
1808 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
1809 name_len2 *= 2; /* convert to bytes */
1810 } else { /* BB improve the check for buffer overruns BB */
1811 name_len = strnlen(fromName, PATH_MAX);
1812 name_len++; /* trailing null */
1813 strncpy(pSMB->OldFileName, fromName, name_len);
1814 name_len2 = strnlen(toName, PATH_MAX);
1815 name_len2++; /* trailing null */
1816 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
1817 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1818 name_len2++; /* trailing null */
1819 name_len2++; /* signature byte */
1820 }
1821
1822 count = 1 /* 1st signature byte */ + name_len + name_len2;
1823 pSMB->hdr.smb_buf_length += count;
1824 pSMB->ByteCount = cpu_to_le16(count);
1825
1826 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1827 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1828 if (rc) {
1829 cFYI(1, ("Send error in copy = %d with %d files copied",
1830 rc, le16_to_cpu(pSMBr->CopyCount)));
1831 }
1832 if (pSMB)
1833 cifs_buf_release(pSMB);
1834
1835 if (rc == -EAGAIN)
1836 goto copyRetry;
1837
1838 return rc;
1839 }
1840
1841 int
1842 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
1843 const char *fromName, const char *toName,
1844 const struct nls_table *nls_codepage)
1845 {
1846 TRANSACTION2_SPI_REQ *pSMB = NULL;
1847 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1848 char *data_offset;
1849 int name_len;
1850 int name_len_target;
1851 int rc = 0;
1852 int bytes_returned = 0;
1853 __u16 params, param_offset, offset, byte_count;
1854
1855 cFYI(1, ("In Symlink Unix style"));
1856 createSymLinkRetry:
1857 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1858 (void **) &pSMBr);
1859 if (rc)
1860 return rc;
1861
1862 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1863 name_len =
1864 cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
1865 /* find define for this maxpathcomponent */
1866 , nls_codepage);
1867 name_len++; /* trailing null */
1868 name_len *= 2;
1869
1870 } else { /* BB improve the check for buffer overruns BB */
1871 name_len = strnlen(fromName, PATH_MAX);
1872 name_len++; /* trailing null */
1873 strncpy(pSMB->FileName, fromName, name_len);
1874 }
1875 params = 6 + name_len;
1876 pSMB->MaxSetupCount = 0;
1877 pSMB->Reserved = 0;
1878 pSMB->Flags = 0;
1879 pSMB->Timeout = 0;
1880 pSMB->Reserved2 = 0;
1881 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1882 InformationLevel) - 4;
1883 offset = param_offset + params;
1884
1885 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1886 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1887 name_len_target =
1888 cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
1889 /* find define for this maxpathcomponent */
1890 , nls_codepage);
1891 name_len_target++; /* trailing null */
1892 name_len_target *= 2;
1893 } else { /* BB improve the check for buffer overruns BB */
1894 name_len_target = strnlen(toName, PATH_MAX);
1895 name_len_target++; /* trailing null */
1896 strncpy(data_offset, toName, name_len_target);
1897 }
1898
1899 pSMB->MaxParameterCount = cpu_to_le16(2);
1900 /* BB find exact max on data count below from sess */
1901 pSMB->MaxDataCount = cpu_to_le16(1000);
1902 pSMB->SetupCount = 1;
1903 pSMB->Reserved3 = 0;
1904 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1905 byte_count = 3 /* pad */ + params + name_len_target;
1906 pSMB->DataCount = cpu_to_le16(name_len_target);
1907 pSMB->ParameterCount = cpu_to_le16(params);
1908 pSMB->TotalDataCount = pSMB->DataCount;
1909 pSMB->TotalParameterCount = pSMB->ParameterCount;
1910 pSMB->ParameterOffset = cpu_to_le16(param_offset);
1911 pSMB->DataOffset = cpu_to_le16(offset);
1912 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
1913 pSMB->Reserved4 = 0;
1914 pSMB->hdr.smb_buf_length += byte_count;
1915 pSMB->ByteCount = cpu_to_le16(byte_count);
1916 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1917 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1918 cifs_stats_inc(&tcon->num_symlinks);
1919 if (rc) {
1920 cFYI(1,
1921 ("Send error in SetPathInfo (create symlink) = %d",
1922 rc));
1923 }
1924
1925 if (pSMB)
1926 cifs_buf_release(pSMB);
1927
1928 if (rc == -EAGAIN)
1929 goto createSymLinkRetry;
1930
1931 return rc;
1932 }
1933
1934 int
1935 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
1936 const char *fromName, const char *toName,
1937 const struct nls_table *nls_codepage, int remap)
1938 {
1939 TRANSACTION2_SPI_REQ *pSMB = NULL;
1940 TRANSACTION2_SPI_RSP *pSMBr = NULL;
1941 char *data_offset;
1942 int name_len;
1943 int name_len_target;
1944 int rc = 0;
1945 int bytes_returned = 0;
1946 __u16 params, param_offset, offset, byte_count;
1947
1948 cFYI(1, ("In Create Hard link Unix style"));
1949 createHardLinkRetry:
1950 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1951 (void **) &pSMBr);
1952 if (rc)
1953 return rc;
1954
1955 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1956 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
1957 PATH_MAX, nls_codepage, remap);
1958 name_len++; /* trailing null */
1959 name_len *= 2;
1960
1961 } else { /* BB improve the check for buffer overruns BB */
1962 name_len = strnlen(toName, PATH_MAX);
1963 name_len++; /* trailing null */
1964 strncpy(pSMB->FileName, toName, name_len);
1965 }
1966 params = 6 + name_len;
1967 pSMB->MaxSetupCount = 0;
1968 pSMB->Reserved = 0;
1969 pSMB->Flags = 0;
1970 pSMB->Timeout = 0;
1971 pSMB->Reserved2 = 0;
1972 param_offset = offsetof(struct smb_com_transaction2_spi_req,
1973 InformationLevel) - 4;
1974 offset = param_offset + params;
1975
1976 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
1977 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1978 name_len_target =
1979 cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
1980 nls_codepage, remap);
1981 name_len_target++; /* trailing null */
1982 name_len_target *= 2;
1983 } else { /* BB improve the check for buffer overruns BB */
1984 name_len_target = strnlen(fromName, PATH_MAX);
1985 name_len_target++; /* trailing null */
1986 strncpy(data_offset, fromName, name_len_target);
1987 }
1988
1989 pSMB->MaxParameterCount = cpu_to_le16(2);
1990 /* BB find exact max on data count below from sess*/
1991 pSMB->MaxDataCount = cpu_to_le16(1000);
1992 pSMB->SetupCount = 1;
1993 pSMB->Reserved3 = 0;
1994 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1995 byte_count = 3 /* pad */ + params + name_len_target;
1996 pSMB->ParameterCount = cpu_to_le16(params);
1997 pSMB->TotalParameterCount = pSMB->ParameterCount;
1998 pSMB->DataCount = cpu_to_le16(name_len_target);
1999 pSMB->TotalDataCount = pSMB->DataCount;
2000 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2001 pSMB->DataOffset = cpu_to_le16(offset);
2002 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2003 pSMB->Reserved4 = 0;
2004 pSMB->hdr.smb_buf_length += byte_count;
2005 pSMB->ByteCount = cpu_to_le16(byte_count);
2006 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2007 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2008 cifs_stats_inc(&tcon->num_hardlinks);
2009 if (rc) {
2010 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
2011 }
2012
2013 cifs_buf_release(pSMB);
2014 if (rc == -EAGAIN)
2015 goto createHardLinkRetry;
2016
2017 return rc;
2018 }
2019
2020 int
2021 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2022 const char *fromName, const char *toName,
2023 const struct nls_table *nls_codepage, int remap)
2024 {
2025 int rc = 0;
2026 NT_RENAME_REQ *pSMB = NULL;
2027 RENAME_RSP *pSMBr = NULL;
2028 int bytes_returned;
2029 int name_len, name_len2;
2030 __u16 count;
2031
2032 cFYI(1, ("In CIFSCreateHardLink"));
2033 winCreateHardLinkRetry:
2034
2035 rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2036 (void **) &pSMBr);
2037 if (rc)
2038 return rc;
2039
2040 pSMB->SearchAttributes =
2041 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2042 ATTR_DIRECTORY);
2043 pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2044 pSMB->ClusterCount = 0;
2045
2046 pSMB->BufferFormat = 0x04;
2047
2048 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2049 name_len =
2050 cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
2051 PATH_MAX, nls_codepage, remap);
2052 name_len++; /* trailing null */
2053 name_len *= 2;
2054 pSMB->OldFileName[name_len] = 0; /* pad */
2055 pSMB->OldFileName[name_len + 1] = 0x04;
2056 name_len2 =
2057 cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2058 toName, PATH_MAX, nls_codepage, remap);
2059 name_len2 += 1 /* trailing null */ + 1 /* Signature word */ ;
2060 name_len2 *= 2; /* convert to bytes */
2061 } else { /* BB improve the check for buffer overruns BB */
2062 name_len = strnlen(fromName, PATH_MAX);
2063 name_len++; /* trailing null */
2064 strncpy(pSMB->OldFileName, fromName, name_len);
2065 name_len2 = strnlen(toName, PATH_MAX);
2066 name_len2++; /* trailing null */
2067 pSMB->OldFileName[name_len] = 0x04; /* 2nd buffer format */
2068 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2069 name_len2++; /* trailing null */
2070 name_len2++; /* signature byte */
2071 }
2072
2073 count = 1 /* string type byte */ + name_len + name_len2;
2074 pSMB->hdr.smb_buf_length += count;
2075 pSMB->ByteCount = cpu_to_le16(count);
2076
2077 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2078 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2079 cifs_stats_inc(&tcon->num_hardlinks);
2080 if (rc) {
2081 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
2082 }
2083 cifs_buf_release(pSMB);
2084 if (rc == -EAGAIN)
2085 goto winCreateHardLinkRetry;
2086
2087 return rc;
2088 }
2089
2090 int
2091 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
2092 const unsigned char *searchName,
2093 char *symlinkinfo, const int buflen,
2094 const struct nls_table *nls_codepage)
2095 {
2096 /* SMB_QUERY_FILE_UNIX_LINK */
2097 TRANSACTION2_QPI_REQ *pSMB = NULL;
2098 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2099 int rc = 0;
2100 int bytes_returned;
2101 int name_len;
2102 __u16 params, byte_count;
2103
2104 cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
2105
2106 querySymLinkRetry:
2107 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2108 (void **) &pSMBr);
2109 if (rc)
2110 return rc;
2111
2112 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2113 name_len =
2114 cifs_strtoUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
2115 /* find define for this maxpathcomponent */
2116 , nls_codepage);
2117 name_len++; /* trailing null */
2118 name_len *= 2;
2119 } else { /* BB improve the check for buffer overruns BB */
2120 name_len = strnlen(searchName, PATH_MAX);
2121 name_len++; /* trailing null */
2122 strncpy(pSMB->FileName, searchName, name_len);
2123 }
2124
2125 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2126 pSMB->TotalDataCount = 0;
2127 pSMB->MaxParameterCount = cpu_to_le16(2);
2128 /* BB find exact max data count below from sess structure BB */
2129 pSMB->MaxDataCount = cpu_to_le16(4000);
2130 pSMB->MaxSetupCount = 0;
2131 pSMB->Reserved = 0;
2132 pSMB->Flags = 0;
2133 pSMB->Timeout = 0;
2134 pSMB->Reserved2 = 0;
2135 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2136 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2137 pSMB->DataCount = 0;
2138 pSMB->DataOffset = 0;
2139 pSMB->SetupCount = 1;
2140 pSMB->Reserved3 = 0;
2141 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2142 byte_count = params + 1 /* pad */ ;
2143 pSMB->TotalParameterCount = cpu_to_le16(params);
2144 pSMB->ParameterCount = pSMB->TotalParameterCount;
2145 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2146 pSMB->Reserved4 = 0;
2147 pSMB->hdr.smb_buf_length += byte_count;
2148 pSMB->ByteCount = cpu_to_le16(byte_count);
2149
2150 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2151 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2152 if (rc) {
2153 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
2154 } else {
2155 /* decode response */
2156
2157 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2158 if (rc || (pSMBr->ByteCount < 2))
2159 /* BB also check enough total bytes returned */
2160 rc = -EIO; /* bad smb */
2161 else {
2162 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2163 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2164
2165 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2166 name_len = UniStrnlen((wchar_t *) ((char *)
2167 &pSMBr->hdr.Protocol +data_offset),
2168 min_t(const int, buflen,count) / 2);
2169 /* BB FIXME investigate remapping reserved chars here */
2170 cifs_strfromUCS_le(symlinkinfo,
2171 (__le16 *) ((char *)&pSMBr->hdr.Protocol +
2172 data_offset),
2173 name_len, nls_codepage);
2174 } else {
2175 strncpy(symlinkinfo,
2176 (char *) &pSMBr->hdr.Protocol +
2177 data_offset,
2178 min_t(const int, buflen, count));
2179 }
2180 symlinkinfo[buflen] = 0;
2181 /* just in case so calling code does not go off the end of buffer */
2182 }
2183 }
2184 cifs_buf_release(pSMB);
2185 if (rc == -EAGAIN)
2186 goto querySymLinkRetry;
2187 return rc;
2188 }
2189
2190 /* Initialize NT TRANSACT SMB into small smb request buffer.
2191 This assumes that all NT TRANSACTS that we init here have
2192 total parm and data under about 400 bytes (to fit in small cifs
2193 buffer size), which is the case so far, it easily fits. NB:
2194 Setup words themselves and ByteCount
2195 MaxSetupCount (size of returned setup area) and
2196 MaxParameterCount (returned parms size) must be set by caller */
2197 static int
2198 smb_init_ntransact(const __u16 sub_command, const int setup_count,
2199 const int parm_len, struct cifsTconInfo *tcon,
2200 void ** ret_buf)
2201 {
2202 int rc;
2203 __u32 temp_offset;
2204 struct smb_com_ntransact_req * pSMB;
2205
2206 rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
2207 (void **)&pSMB);
2208 if (rc)
2209 return rc;
2210 *ret_buf = (void *)pSMB;
2211 pSMB->Reserved = 0;
2212 pSMB->TotalParameterCount = cpu_to_le32(parm_len);
2213 pSMB->TotalDataCount = 0;
2214 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2215 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2216 pSMB->ParameterCount = pSMB->TotalParameterCount;
2217 pSMB->DataCount = pSMB->TotalDataCount;
2218 temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
2219 (setup_count * 2) - 4 /* for rfc1001 length itself */;
2220 pSMB->ParameterOffset = cpu_to_le32(temp_offset);
2221 pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
2222 pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
2223 pSMB->SubCommand = cpu_to_le16(sub_command);
2224 return 0;
2225 }
2226
2227 static int
2228 validate_ntransact(char * buf, char ** ppparm, char ** ppdata,
2229 int * pdatalen, int * pparmlen)
2230 {
2231 char * end_of_smb;
2232 __u32 data_count, data_offset, parm_count, parm_offset;
2233 struct smb_com_ntransact_rsp * pSMBr;
2234
2235 if(buf == NULL)
2236 return -EINVAL;
2237
2238 pSMBr = (struct smb_com_ntransact_rsp *)buf;
2239
2240 /* ByteCount was converted from little endian in SendReceive */
2241 end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2242 (char *)&pSMBr->ByteCount;
2243
2244
2245 data_offset = le32_to_cpu(pSMBr->DataOffset);
2246 data_count = le32_to_cpu(pSMBr->DataCount);
2247 parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2248 parm_count = le32_to_cpu(pSMBr->ParameterCount);
2249
2250 *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2251 *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2252
2253 /* should we also check that parm and data areas do not overlap? */
2254 if(*ppparm > end_of_smb) {
2255 cFYI(1,("parms start after end of smb"));
2256 return -EINVAL;
2257 } else if(parm_count + *ppparm > end_of_smb) {
2258 cFYI(1,("parm end after end of smb"));
2259 return -EINVAL;
2260 } else if(*ppdata > end_of_smb) {
2261 cFYI(1,("data starts after end of smb"));
2262 return -EINVAL;
2263 } else if(data_count + *ppdata > end_of_smb) {
2264 cFYI(1,("data %p + count %d (%p) ends after end of smb %p start %p",
2265 *ppdata, data_count, (data_count + *ppdata), end_of_smb, pSMBr)); /* BB FIXME */
2266 return -EINVAL;
2267 } else if(parm_count + data_count > pSMBr->ByteCount) {
2268 cFYI(1,("parm count and data count larger than SMB"));
2269 return -EINVAL;
2270 }
2271 return 0;
2272 }
2273
2274 int
2275 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
2276 const unsigned char *searchName,
2277 char *symlinkinfo, const int buflen,__u16 fid,
2278 const struct nls_table *nls_codepage)
2279 {
2280 int rc = 0;
2281 int bytes_returned;
2282 int name_len;
2283 struct smb_com_transaction_ioctl_req * pSMB;
2284 struct smb_com_transaction_ioctl_rsp * pSMBr;
2285
2286 cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
2287 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2288 (void **) &pSMBr);
2289 if (rc)
2290 return rc;
2291
2292 pSMB->TotalParameterCount = 0 ;
2293 pSMB->TotalDataCount = 0;
2294 pSMB->MaxParameterCount = cpu_to_le32(2);
2295 /* BB find exact data count max from sess structure BB */
2296 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2297 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2298 pSMB->MaxSetupCount = 4;
2299 pSMB->Reserved = 0;
2300 pSMB->ParameterOffset = 0;
2301 pSMB->DataCount = 0;
2302 pSMB->DataOffset = 0;
2303 pSMB->SetupCount = 4;
2304 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2305 pSMB->ParameterCount = pSMB->TotalParameterCount;
2306 pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2307 pSMB->IsFsctl = 1; /* FSCTL */
2308 pSMB->IsRootFlag = 0;
2309 pSMB->Fid = fid; /* file handle always le */
2310 pSMB->ByteCount = 0;
2311
2312 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2313 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2314 if (rc) {
2315 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
2316 } else { /* decode response */
2317 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
2318 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
2319 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
2320 /* BB also check enough total bytes returned */
2321 rc = -EIO; /* bad smb */
2322 else {
2323 if(data_count && (data_count < 2048)) {
2324 char * end_of_smb = 2 /* sizeof byte count */ +
2325 pSMBr->ByteCount +
2326 (char *)&pSMBr->ByteCount;
2327
2328 struct reparse_data * reparse_buf = (struct reparse_data *)
2329 ((char *)&pSMBr->hdr.Protocol + data_offset);
2330 if((char*)reparse_buf >= end_of_smb) {
2331 rc = -EIO;
2332 goto qreparse_out;
2333 }
2334 if((reparse_buf->LinkNamesBuf +
2335 reparse_buf->TargetNameOffset +
2336 reparse_buf->TargetNameLen) >
2337 end_of_smb) {
2338 cFYI(1,("reparse buf extended beyond SMB"));
2339 rc = -EIO;
2340 goto qreparse_out;
2341 }
2342
2343 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2344 name_len = UniStrnlen((wchar_t *)
2345 (reparse_buf->LinkNamesBuf +
2346 reparse_buf->TargetNameOffset),
2347 min(buflen/2, reparse_buf->TargetNameLen / 2));
2348 cifs_strfromUCS_le(symlinkinfo,
2349 (__le16 *) (reparse_buf->LinkNamesBuf +
2350 reparse_buf->TargetNameOffset),
2351 name_len, nls_codepage);
2352 } else { /* ASCII names */
2353 strncpy(symlinkinfo,reparse_buf->LinkNamesBuf +
2354 reparse_buf->TargetNameOffset,
2355 min_t(const int, buflen, reparse_buf->TargetNameLen));
2356 }
2357 } else {
2358 rc = -EIO;
2359 cFYI(1,("Invalid return data count on get reparse info ioctl"));
2360 }
2361 symlinkinfo[buflen] = 0; /* just in case so the caller
2362 does not go off the end of the buffer */
2363 cFYI(1,("readlink result - %s",symlinkinfo));
2364 }
2365 }
2366 qreparse_out:
2367 cifs_buf_release(pSMB);
2368
2369 /* Note: On -EAGAIN error only caller can retry on handle based calls
2370 since file handle passed in no longer valid */
2371
2372 return rc;
2373 }
2374
2375 #ifdef CONFIG_CIFS_POSIX
2376
2377 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
2378 static void cifs_convert_ace(posix_acl_xattr_entry * ace, struct cifs_posix_ace * cifs_ace)
2379 {
2380 /* u8 cifs fields do not need le conversion */
2381 ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
2382 ace->e_tag = cpu_to_le16(cifs_ace->cifs_e_tag);
2383 ace->e_id = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
2384 /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
2385
2386 return;
2387 }
2388
2389 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
2390 static int cifs_copy_posix_acl(char * trgt,char * src, const int buflen,
2391 const int acl_type,const int size_of_data_area)
2392 {
2393 int size = 0;
2394 int i;
2395 __u16 count;
2396 struct cifs_posix_ace * pACE;
2397 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)src;
2398 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)trgt;
2399
2400 if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2401 return -EOPNOTSUPP;
2402
2403 if(acl_type & ACL_TYPE_ACCESS) {
2404 count = le16_to_cpu(cifs_acl->access_entry_count);
2405 pACE = &cifs_acl->ace_array[0];
2406 size = sizeof(struct cifs_posix_acl);
2407 size += sizeof(struct cifs_posix_ace) * count;
2408 /* check if we would go beyond end of SMB */
2409 if(size_of_data_area < size) {
2410 cFYI(1,("bad CIFS POSIX ACL size %d vs. %d",size_of_data_area,size));
2411 return -EINVAL;
2412 }
2413 } else if(acl_type & ACL_TYPE_DEFAULT) {
2414 count = le16_to_cpu(cifs_acl->access_entry_count);
2415 size = sizeof(struct cifs_posix_acl);
2416 size += sizeof(struct cifs_posix_ace) * count;
2417 /* skip past access ACEs to get to default ACEs */
2418 pACE = &cifs_acl->ace_array[count];
2419 count = le16_to_cpu(cifs_acl->default_entry_count);
2420 size += sizeof(struct cifs_posix_ace) * count;
2421 /* check if we would go beyond end of SMB */
2422 if(size_of_data_area < size)
2423 return -EINVAL;
2424 } else {
2425 /* illegal type */
2426 return -EINVAL;
2427 }
2428
2429 size = posix_acl_xattr_size(count);
2430 if((buflen == 0) || (local_acl == NULL)) {
2431 /* used to query ACL EA size */
2432 } else if(size > buflen) {
2433 return -ERANGE;
2434 } else /* buffer big enough */ {
2435 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
2436 for(i = 0;i < count ;i++) {
2437 cifs_convert_ace(&local_acl->a_entries[i],pACE);
2438 pACE ++;
2439 }
2440 }
2441 return size;
2442 }
2443
2444 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace * cifs_ace,
2445 const posix_acl_xattr_entry * local_ace)
2446 {
2447 __u16 rc = 0; /* 0 = ACL converted ok */
2448
2449 cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
2450 cifs_ace->cifs_e_tag = le16_to_cpu(local_ace->e_tag);
2451 /* BB is there a better way to handle the large uid? */
2452 if(local_ace->e_id == cpu_to_le32(-1)) {
2453 /* Probably no need to le convert -1 on any arch but can not hurt */
2454 cifs_ace->cifs_uid = cpu_to_le64(-1);
2455 } else
2456 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
2457 /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
2458 return rc;
2459 }
2460
2461 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
2462 static __u16 ACL_to_cifs_posix(char * parm_data,const char * pACL,const int buflen,
2463 const int acl_type)
2464 {
2465 __u16 rc = 0;
2466 struct cifs_posix_acl * cifs_acl = (struct cifs_posix_acl *)parm_data;
2467 posix_acl_xattr_header * local_acl = (posix_acl_xattr_header *)pACL;
2468 int count;
2469 int i;
2470
2471 if((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
2472 return 0;
2473
2474 count = posix_acl_xattr_count((size_t)buflen);
2475 cFYI(1,("setting acl with %d entries from buf of length %d and version of %d",
2476 count, buflen, le32_to_cpu(local_acl->a_version)));
2477 if(le32_to_cpu(local_acl->a_version) != 2) {
2478 cFYI(1,("unknown POSIX ACL version %d",
2479 le32_to_cpu(local_acl->a_version)));
2480 return 0;
2481 }
2482 cifs_acl->version = cpu_to_le16(1);
2483 if(acl_type == ACL_TYPE_ACCESS)
2484 cifs_acl->access_entry_count = cpu_to_le16(count);
2485 else if(acl_type == ACL_TYPE_DEFAULT)
2486 cifs_acl->default_entry_count = cpu_to_le16(count);
2487 else {
2488 cFYI(1,("unknown ACL type %d",acl_type));
2489 return 0;
2490 }
2491 for(i=0;i<count;i++) {
2492 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
2493 &local_acl->a_entries[i]);
2494 if(rc != 0) {
2495 /* ACE not converted */
2496 break;
2497 }
2498 }
2499 if(rc == 0) {
2500 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
2501 rc += sizeof(struct cifs_posix_acl);
2502 /* BB add check to make sure ACL does not overflow SMB */
2503 }
2504 return rc;
2505 }
2506
2507 int
2508 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
2509 const unsigned char *searchName,
2510 char *acl_inf, const int buflen, const int acl_type,
2511 const struct nls_table *nls_codepage, int remap)
2512 {
2513 /* SMB_QUERY_POSIX_ACL */
2514 TRANSACTION2_QPI_REQ *pSMB = NULL;
2515 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2516 int rc = 0;
2517 int bytes_returned;
2518 int name_len;
2519 __u16 params, byte_count;
2520
2521 cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
2522
2523 queryAclRetry:
2524 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2525 (void **) &pSMBr);
2526 if (rc)
2527 return rc;
2528
2529 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2530 name_len =
2531 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2532 PATH_MAX, nls_codepage, remap);
2533 name_len++; /* trailing null */
2534 name_len *= 2;
2535 pSMB->FileName[name_len] = 0;
2536 pSMB->FileName[name_len+1] = 0;
2537 } else { /* BB improve the check for buffer overruns BB */
2538 name_len = strnlen(searchName, PATH_MAX);
2539 name_len++; /* trailing null */
2540 strncpy(pSMB->FileName, searchName, name_len);
2541 }
2542
2543 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
2544 pSMB->TotalDataCount = 0;
2545 pSMB->MaxParameterCount = cpu_to_le16(2);
2546 /* BB find exact max data count below from sess structure BB */
2547 pSMB->MaxDataCount = cpu_to_le16(4000);
2548 pSMB->MaxSetupCount = 0;
2549 pSMB->Reserved = 0;
2550 pSMB->Flags = 0;
2551 pSMB->Timeout = 0;
2552 pSMB->Reserved2 = 0;
2553 pSMB->ParameterOffset = cpu_to_le16(
2554 offsetof(struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2555 pSMB->DataCount = 0;
2556 pSMB->DataOffset = 0;
2557 pSMB->SetupCount = 1;
2558 pSMB->Reserved3 = 0;
2559 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2560 byte_count = params + 1 /* pad */ ;
2561 pSMB->TotalParameterCount = cpu_to_le16(params);
2562 pSMB->ParameterCount = pSMB->TotalParameterCount;
2563 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
2564 pSMB->Reserved4 = 0;
2565 pSMB->hdr.smb_buf_length += byte_count;
2566 pSMB->ByteCount = cpu_to_le16(byte_count);
2567
2568 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2569 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2570 cifs_stats_inc(&tcon->num_acl_get);
2571 if (rc) {
2572 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
2573 } else {
2574 /* decode response */
2575
2576 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2577 if (rc || (pSMBr->ByteCount < 2))
2578 /* BB also check enough total bytes returned */
2579 rc = -EIO; /* bad smb */
2580 else {
2581 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2582 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2583 rc = cifs_copy_posix_acl(acl_inf,
2584 (char *)&pSMBr->hdr.Protocol+data_offset,
2585 buflen,acl_type,count);
2586 }
2587 }
2588 cifs_buf_release(pSMB);
2589 if (rc == -EAGAIN)
2590 goto queryAclRetry;
2591 return rc;
2592 }
2593
2594 int
2595 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2596 const unsigned char *fileName,
2597 const char *local_acl, const int buflen,
2598 const int acl_type,
2599 const struct nls_table *nls_codepage, int remap)
2600 {
2601 struct smb_com_transaction2_spi_req *pSMB = NULL;
2602 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2603 char *parm_data;
2604 int name_len;
2605 int rc = 0;
2606 int bytes_returned = 0;
2607 __u16 params, byte_count, data_count, param_offset, offset;
2608
2609 cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2610 setAclRetry:
2611 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2612 (void **) &pSMBr);
2613 if (rc)
2614 return rc;
2615 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2616 name_len =
2617 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2618 PATH_MAX, nls_codepage, remap);
2619 name_len++; /* trailing null */
2620 name_len *= 2;
2621 } else { /* BB improve the check for buffer overruns BB */
2622 name_len = strnlen(fileName, PATH_MAX);
2623 name_len++; /* trailing null */
2624 strncpy(pSMB->FileName, fileName, name_len);
2625 }
2626 params = 6 + name_len;
2627 pSMB->MaxParameterCount = cpu_to_le16(2);
2628 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2629 pSMB->MaxSetupCount = 0;
2630 pSMB->Reserved = 0;
2631 pSMB->Flags = 0;
2632 pSMB->Timeout = 0;
2633 pSMB->Reserved2 = 0;
2634 param_offset = offsetof(struct smb_com_transaction2_spi_req,
2635 InformationLevel) - 4;
2636 offset = param_offset + params;
2637 parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2638 pSMB->ParameterOffset = cpu_to_le16(param_offset);
2639
2640 /* convert to on the wire format for POSIX ACL */
2641 data_count = ACL_to_cifs_posix(parm_data,local_acl,buflen,acl_type);
2642
2643 if(data_count == 0) {
2644 rc = -EOPNOTSUPP;
2645 goto setACLerrorExit;
2646 }
2647 pSMB->DataOffset = cpu_to_le16(offset);
2648 pSMB->SetupCount = 1;
2649 pSMB->Reserved3 = 0;
2650 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2651 pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2652 byte_count = 3 /* pad */ + params + data_count;
2653 pSMB->DataCount = cpu_to_le16(data_count);
2654 pSMB->TotalDataCount = pSMB->DataCount;
2655 pSMB->ParameterCount = cpu_to_le16(params);
2656 pSMB->TotalParameterCount = pSMB->ParameterCount;
2657 pSMB->Reserved4 = 0;
2658 pSMB->hdr.smb_buf_length += byte_count;
2659 pSMB->ByteCount = cpu_to_le16(byte_count);
2660 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2661 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2662 if (rc) {
2663 cFYI(1, ("Set POSIX ACL returned %d", rc));
2664 }
2665
2666 setACLerrorExit:
2667 cifs_buf_release(pSMB);
2668 if (rc == -EAGAIN)
2669 goto setAclRetry;
2670 return rc;
2671 }
2672
2673 /* BB fix tabs in this function FIXME BB */
2674 int
2675 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2676 const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
2677 {
2678 int rc = 0;
2679 struct smb_t2_qfi_req *pSMB = NULL;
2680 struct smb_t2_qfi_rsp *pSMBr = NULL;
2681 int bytes_returned;
2682 __u16 params, byte_count;
2683
2684 cFYI(1,("In GetExtAttr"));
2685 if(tcon == NULL)
2686 return -ENODEV;
2687
2688 GetExtAttrRetry:
2689 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2690 (void **) &pSMBr);
2691 if (rc)
2692 return rc;
2693
2694 params = 2 /* level */ +2 /* fid */;
2695 pSMB->t2.TotalDataCount = 0;
2696 pSMB->t2.MaxParameterCount = cpu_to_le16(4);
2697 /* BB find exact max data count below from sess structure BB */
2698 pSMB->t2.MaxDataCount = cpu_to_le16(4000);
2699 pSMB->t2.MaxSetupCount = 0;
2700 pSMB->t2.Reserved = 0;
2701 pSMB->t2.Flags = 0;
2702 pSMB->t2.Timeout = 0;
2703 pSMB->t2.Reserved2 = 0;
2704 pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
2705 Fid) - 4);
2706 pSMB->t2.DataCount = 0;
2707 pSMB->t2.DataOffset = 0;
2708 pSMB->t2.SetupCount = 1;
2709 pSMB->t2.Reserved3 = 0;
2710 pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2711 byte_count = params + 1 /* pad */ ;
2712 pSMB->t2.TotalParameterCount = cpu_to_le16(params);
2713 pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
2714 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
2715 pSMB->Pad = 0;
2716 pSMB->Fid = netfid;
2717 pSMB->hdr.smb_buf_length += byte_count;
2718 pSMB->t2.ByteCount = cpu_to_le16(byte_count);
2719
2720 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2721 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2722 if (rc) {
2723 cFYI(1, ("error %d in GetExtAttr", rc));
2724 } else {
2725 /* decode response */
2726 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2727 if (rc || (pSMBr->ByteCount < 2))
2728 /* BB also check enough total bytes returned */
2729 /* If rc should we check for EOPNOSUPP and
2730 disable the srvino flag? or in caller? */
2731 rc = -EIO; /* bad smb */
2732 else {
2733 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2734 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2735 struct file_chattr_info * pfinfo;
2736 /* BB Do we need a cast or hash here ? */
2737 if(count != 16) {
2738 cFYI(1, ("Illegal size ret in GetExtAttr"));
2739 rc = -EIO;
2740 goto GetExtAttrOut;
2741 }
2742 pfinfo = (struct file_chattr_info *)
2743 (data_offset + (char *) &pSMBr->hdr.Protocol);
2744 *pExtAttrBits = le64_to_cpu(pfinfo->mode);
2745 *pMask = le64_to_cpu(pfinfo->mask);
2746 }
2747 }
2748 GetExtAttrOut:
2749 cifs_buf_release(pSMB);
2750 if (rc == -EAGAIN)
2751 goto GetExtAttrRetry;
2752 return rc;
2753 }
2754
2755
2756 #endif /* CONFIG_POSIX */
2757
2758
2759 /* security id for everyone */
2760 const struct cifs_sid sid_everyone = {1, 1, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0}};
2761 /* group users */
2762 const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {32, 545, 0, 0}};
2763
2764 /* Convert CIFS ACL to POSIX form */
2765 static int parse_sec_desc(struct cifs_sid * psec_desc, int acl_len)
2766 {
2767 return 0;
2768 }
2769
2770 /* Get Security Descriptor (by handle) from remote server for a file or dir */
2771 int
2772 CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
2773 /* BB fix up return info */ char *acl_inf, const int buflen,
2774 const int acl_type /* ACCESS/DEFAULT not sure implication */)
2775 {
2776 int rc = 0;
2777 int buf_type = 0;
2778 QUERY_SEC_DESC_REQ * pSMB;
2779 struct kvec iov[1];
2780
2781 cFYI(1, ("GetCifsACL"));
2782
2783 rc = smb_init_ntransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
2784 8 /* parm len */, tcon, (void **) &pSMB);
2785 if (rc)
2786 return rc;
2787
2788 pSMB->MaxParameterCount = cpu_to_le32(4);
2789 /* BB TEST with big acls that might need to be e.g. larger than 16K */
2790 pSMB->MaxSetupCount = 0;
2791 pSMB->Fid = fid; /* file handle always le */
2792 pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
2793 CIFS_ACL_DACL);
2794 pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
2795 pSMB->hdr.smb_buf_length += 11;
2796 iov[0].iov_base = (char *)pSMB;
2797 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
2798
2799 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type, 0);
2800 cifs_stats_inc(&tcon->num_acl_get);
2801 if (rc) {
2802 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
2803 } else { /* decode response */
2804 struct cifs_sid * psec_desc;
2805 __le32 * parm;
2806 int parm_len;
2807 int data_len;
2808 int acl_len;
2809 struct smb_com_ntransact_rsp * pSMBr;
2810
2811 /* validate_nttransact */
2812 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
2813 (char **)&psec_desc,
2814 &parm_len, &data_len);
2815
2816 if(rc)
2817 goto qsec_out;
2818 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
2819
2820 cERROR(1,("smb %p parm %p data %p",pSMBr,parm,psec_desc)); /* BB removeme BB */
2821
2822 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
2823 rc = -EIO; /* bad smb */
2824 goto qsec_out;
2825 }
2826
2827 /* BB check that data area is minimum length and as big as acl_len */
2828
2829 acl_len = le32_to_cpu(*(__le32 *)parm);
2830 /* BB check if(acl_len > bufsize) */
2831
2832 parse_sec_desc(psec_desc, acl_len);
2833 }
2834 qsec_out:
2835 if(buf_type == CIFS_SMALL_BUFFER)
2836 cifs_small_buf_release(iov[0].iov_base);
2837 else if(buf_type == CIFS_LARGE_BUFFER)
2838 cifs_buf_release(iov[0].iov_base);
2839 /* cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
2840 return rc;
2841 }
2842
2843
2844 /* Legacy Query Path Information call for lookup to old servers such
2845 as Win9x/WinME */
2846 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
2847 const unsigned char *searchName,
2848 FILE_ALL_INFO * pFinfo,
2849 const struct nls_table *nls_codepage, int remap)
2850 {
2851 QUERY_INFORMATION_REQ * pSMB;
2852 QUERY_INFORMATION_RSP * pSMBr;
2853 int rc = 0;
2854 int bytes_returned;
2855 int name_len;
2856
2857 cFYI(1, ("In SMBQPath path %s", searchName));
2858 QInfRetry:
2859 rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
2860 (void **) &pSMBr);
2861 if (rc)
2862 return rc;
2863
2864 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2865 name_len =
2866 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2867 PATH_MAX, nls_codepage, remap);
2868 name_len++; /* trailing null */
2869 name_len *= 2;
2870 } else {
2871 name_len = strnlen(searchName, PATH_MAX);
2872 name_len++; /* trailing null */
2873 strncpy(pSMB->FileName, searchName, name_len);
2874 }
2875 pSMB->BufferFormat = 0x04;
2876 name_len++; /* account for buffer type byte */
2877 pSMB->hdr.smb_buf_length += (__u16) name_len;
2878 pSMB->ByteCount = cpu_to_le16(name_len);
2879
2880 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2881 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2882 if (rc) {
2883 cFYI(1, ("Send error in QueryInfo = %d", rc));
2884 } else if (pFinfo) { /* decode response */
2885 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
2886 pFinfo->AllocationSize =
2887 cpu_to_le64(le32_to_cpu(pSMBr->size));
2888 pFinfo->EndOfFile = pFinfo->AllocationSize;
2889 pFinfo->Attributes =
2890 cpu_to_le32(le16_to_cpu(pSMBr->attr));
2891 } else
2892 rc = -EIO; /* bad buffer passed in */
2893
2894 cifs_buf_release(pSMB);
2895
2896 if (rc == -EAGAIN)
2897 goto QInfRetry;
2898
2899 return rc;
2900 }
2901
2902
2903
2904
2905 int
2906 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
2907 const unsigned char *searchName,
2908 FILE_ALL_INFO * pFindData,
2909 const struct nls_table *nls_codepage, int remap)
2910 {
2911 /* level 263 SMB_QUERY_FILE_ALL_INFO */
2912 TRANSACTION2_QPI_REQ *pSMB = NULL;
2913 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2914 int rc = 0;
2915 int bytes_returned;
2916 int name_len;
2917 __u16 params, byte_count;
2918
2919 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
2920 QPathInfoRetry:
2921 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2922 (void **) &pSMBr);
2923 if (rc)
2924 return rc;
2925
2926 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2927 name_len =
2928 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2929 PATH_MAX, nls_codepage, remap);
2930 name_len++; /* trailing null */
2931 name_len *= 2;
2932 } else { /* BB improve the check for buffer overruns BB */
2933 name_len = strnlen(searchName, PATH_MAX);
2934 name_len++; /* trailing null */
2935 strncpy(pSMB->FileName, searchName, name_len);
2936 }
2937
2938 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
2939 pSMB->TotalDataCount = 0;
2940 pSMB->MaxParameterCount = cpu_to_le16(2);
2941 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
2942 pSMB->MaxSetupCount = 0;
2943 pSMB->Reserved = 0;
2944 pSMB->Flags = 0;
2945 pSMB->Timeout = 0;
2946 pSMB->Reserved2 = 0;
2947 pSMB->ParameterOffset = cpu_to_le16(offsetof(
2948 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
2949 pSMB->DataCount = 0;
2950 pSMB->DataOffset = 0;
2951 pSMB->SetupCount = 1;
2952 pSMB->Reserved3 = 0;
2953 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2954 byte_count = params + 1 /* pad */ ;
2955 pSMB->TotalParameterCount = cpu_to_le16(params);
2956 pSMB->ParameterCount = pSMB->TotalParameterCount;
2957 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
2958 pSMB->Reserved4 = 0;
2959 pSMB->hdr.smb_buf_length += byte_count;
2960 pSMB->ByteCount = cpu_to_le16(byte_count);
2961
2962 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2963 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2964 if (rc) {
2965 cFYI(1, ("Send error in QPathInfo = %d", rc));
2966 } else { /* decode response */
2967 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2968
2969 if (rc || (pSMBr->ByteCount < 40))
2970 rc = -EIO; /* bad smb */
2971 else if (pFindData){
2972 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2973 memcpy((char *) pFindData,
2974 (char *) &pSMBr->hdr.Protocol +
2975 data_offset, sizeof (FILE_ALL_INFO));
2976 } else
2977 rc = -ENOMEM;
2978 }
2979 cifs_buf_release(pSMB);
2980 if (rc == -EAGAIN)
2981 goto QPathInfoRetry;
2982
2983 return rc;
2984 }
2985
2986 int
2987 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
2988 const unsigned char *searchName,
2989 FILE_UNIX_BASIC_INFO * pFindData,
2990 const struct nls_table *nls_codepage, int remap)
2991 {
2992 /* SMB_QUERY_FILE_UNIX_BASIC */
2993 TRANSACTION2_QPI_REQ *pSMB = NULL;
2994 TRANSACTION2_QPI_RSP *pSMBr = NULL;
2995 int rc = 0;
2996 int bytes_returned = 0;
2997 int name_len;
2998 __u16 params, byte_count;
2999
3000 cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
3001 UnixQPathInfoRetry:
3002 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3003 (void **) &pSMBr);
3004 if (rc)
3005 return rc;
3006
3007 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3008 name_len =
3009 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3010 PATH_MAX, nls_codepage, remap);
3011 name_len++; /* trailing null */
3012 name_len *= 2;
3013 } else { /* BB improve the check for buffer overruns BB */
3014 name_len = strnlen(searchName, PATH_MAX);
3015 name_len++; /* trailing null */
3016 strncpy(pSMB->FileName, searchName, name_len);
3017 }
3018
3019 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
3020 pSMB->TotalDataCount = 0;
3021 pSMB->MaxParameterCount = cpu_to_le16(2);
3022 /* BB find exact max SMB PDU from sess structure BB */
3023 pSMB->MaxDataCount = cpu_to_le16(4000);
3024 pSMB->MaxSetupCount = 0;
3025 pSMB->Reserved = 0;
3026 pSMB->Flags = 0;
3027 pSMB->Timeout = 0;
3028 pSMB->Reserved2 = 0;
3029 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3030 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3031 pSMB->DataCount = 0;
3032 pSMB->DataOffset = 0;
3033 pSMB->SetupCount = 1;
3034 pSMB->Reserved3 = 0;
3035 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3036 byte_count = params + 1 /* pad */ ;
3037 pSMB->TotalParameterCount = cpu_to_le16(params);
3038 pSMB->ParameterCount = pSMB->TotalParameterCount;
3039 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3040 pSMB->Reserved4 = 0;
3041 pSMB->hdr.smb_buf_length += byte_count;
3042 pSMB->ByteCount = cpu_to_le16(byte_count);
3043
3044 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3045 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3046 if (rc) {
3047 cFYI(1, ("Send error in QPathInfo = %d", rc));
3048 } else { /* decode response */
3049 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3050
3051 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
3052 rc = -EIO; /* bad smb */
3053 } else {
3054 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3055 memcpy((char *) pFindData,
3056 (char *) &pSMBr->hdr.Protocol +
3057 data_offset,
3058 sizeof (FILE_UNIX_BASIC_INFO));
3059 }
3060 }
3061 cifs_buf_release(pSMB);
3062 if (rc == -EAGAIN)
3063 goto UnixQPathInfoRetry;
3064
3065 return rc;
3066 }
3067
3068 #if 0 /* function unused at present */
3069 int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
3070 const char *searchName, FILE_ALL_INFO * findData,
3071 const struct nls_table *nls_codepage)
3072 {
3073 /* level 257 SMB_ */
3074 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3075 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3076 int rc = 0;
3077 int bytes_returned;
3078 int name_len;
3079 __u16 params, byte_count;
3080
3081 cFYI(1, ("In FindUnique"));
3082 findUniqueRetry:
3083 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3084 (void **) &pSMBr);
3085 if (rc)
3086 return rc;
3087
3088 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3089 name_len =
3090 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName, PATH_MAX
3091 /* find define for this maxpathcomponent */
3092 , nls_codepage);
3093 name_len++; /* trailing null */
3094 name_len *= 2;
3095 } else { /* BB improve the check for buffer overruns BB */
3096 name_len = strnlen(searchName, PATH_MAX);
3097 name_len++; /* trailing null */
3098 strncpy(pSMB->FileName, searchName, name_len);
3099 }
3100
3101 params = 12 + name_len /* includes null */ ;
3102 pSMB->TotalDataCount = 0; /* no EAs */
3103 pSMB->MaxParameterCount = cpu_to_le16(2);
3104 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3105 pSMB->MaxSetupCount = 0;
3106 pSMB->Reserved = 0;
3107 pSMB->Flags = 0;
3108 pSMB->Timeout = 0;
3109 pSMB->Reserved2 = 0;
3110 pSMB->ParameterOffset = cpu_to_le16(
3111 offsetof(struct smb_com_transaction2_ffirst_req,InformationLevel) - 4);
3112 pSMB->DataCount = 0;
3113 pSMB->DataOffset = 0;
3114 pSMB->SetupCount = 1; /* one byte, no need to le convert */
3115 pSMB->Reserved3 = 0;
3116 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3117 byte_count = params + 1 /* pad */ ;
3118 pSMB->TotalParameterCount = cpu_to_le16(params);
3119 pSMB->ParameterCount = pSMB->TotalParameterCount;
3120 pSMB->SearchAttributes =
3121 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3122 ATTR_DIRECTORY);
3123 pSMB->SearchCount = cpu_to_le16(16); /* BB increase */
3124 pSMB->SearchFlags = cpu_to_le16(1);
3125 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
3126 pSMB->SearchStorageType = 0; /* BB what should we set this to? BB */
3127 pSMB->hdr.smb_buf_length += byte_count;
3128 pSMB->ByteCount = cpu_to_le16(byte_count);
3129
3130 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3131 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3132
3133 if (rc) {
3134 cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
3135 } else { /* decode response */
3136 cifs_stats_inc(&tcon->num_ffirst);
3137 /* BB fill in */
3138 }
3139
3140 cifs_buf_release(pSMB);
3141 if (rc == -EAGAIN)
3142 goto findUniqueRetry;
3143
3144 return rc;
3145 }
3146 #endif /* end unused (temporarily) function */
3147
3148 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3149 int
3150 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
3151 const char *searchName,
3152 const struct nls_table *nls_codepage,
3153 __u16 * pnetfid,
3154 struct cifs_search_info * psrch_inf, int remap, const char dirsep)
3155 {
3156 /* level 257 SMB_ */
3157 TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3158 TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3159 T2_FFIRST_RSP_PARMS * parms;
3160 int rc = 0;
3161 int bytes_returned = 0;
3162 int name_len;
3163 __u16 params, byte_count;
3164
3165 cFYI(1, ("In FindFirst for %s",searchName));
3166
3167 findFirstRetry:
3168 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3169 (void **) &pSMBr);
3170 if (rc)
3171 return rc;
3172
3173 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3174 name_len =
3175 cifsConvertToUCS((__le16 *) pSMB->FileName,searchName,
3176 PATH_MAX, nls_codepage, remap);
3177 /* We can not add the asterik earlier in case
3178 it got remapped to 0xF03A as if it were part of the
3179 directory name instead of a wildcard */
3180 name_len *= 2;
3181 pSMB->FileName[name_len] = dirsep;
3182 pSMB->FileName[name_len+1] = 0;
3183 pSMB->FileName[name_len+2] = '*';
3184 pSMB->FileName[name_len+3] = 0;
3185 name_len += 4; /* now the trailing null */
3186 pSMB->FileName[name_len] = 0; /* null terminate just in case */
3187 pSMB->FileName[name_len+1] = 0;
3188 name_len += 2;
3189 } else { /* BB add check for overrun of SMB buf BB */
3190 name_len = strnlen(searchName, PATH_MAX);
3191 /* BB fix here and in unicode clause above ie
3192 if(name_len > buffersize-header)
3193 free buffer exit; BB */
3194 strncpy(pSMB->FileName, searchName, name_len);
3195 pSMB->FileName[name_len] = dirsep;
3196 pSMB->FileName[name_len+1] = '*';
3197 pSMB->FileName[name_len+2] = 0;
3198 name_len += 3;
3199 }
3200
3201 params = 12 + name_len /* includes null */ ;
3202 pSMB->TotalDataCount = 0; /* no EAs */
3203 pSMB->MaxParameterCount = cpu_to_le16(10);
3204 pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
3205 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3206 pSMB->MaxSetupCount = 0;
3207 pSMB->Reserved = 0;
3208 pSMB->Flags = 0;
3209 pSMB->Timeout = 0;
3210 pSMB->Reserved2 = 0;
3211 byte_count = params + 1 /* pad */ ;
3212 pSMB->TotalParameterCount = cpu_to_le16(params);
3213 pSMB->ParameterCount = pSMB->TotalParameterCount;
3214 pSMB->ParameterOffset = cpu_to_le16(
3215 offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3216 - 4);
3217 pSMB->DataCount = 0;
3218 pSMB->DataOffset = 0;
3219 pSMB->SetupCount = 1; /* one byte, no need to make endian neutral */
3220 pSMB->Reserved3 = 0;
3221 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3222 pSMB->SearchAttributes =
3223 cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3224 ATTR_DIRECTORY);
3225 pSMB->SearchCount= cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3226 pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
3227 CIFS_SEARCH_RETURN_RESUME);
3228 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3229
3230 /* BB what should we set StorageType to? Does it matter? BB */
3231 pSMB->SearchStorageType = 0;
3232 pSMB->hdr.smb_buf_length += byte_count;
3233 pSMB->ByteCount = cpu_to_le16(byte_count);
3234
3235 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3236 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3237 cifs_stats_inc(&tcon->num_ffirst);
3238
3239 if (rc) {/* BB add logic to retry regular search if Unix search
3240 rejected unexpectedly by server */
3241 /* BB Add code to handle unsupported level rc */
3242 cFYI(1, ("Error in FindFirst = %d", rc));
3243
3244 cifs_buf_release(pSMB);
3245
3246 /* BB eventually could optimize out free and realloc of buf */
3247 /* for this case */
3248 if (rc == -EAGAIN)
3249 goto findFirstRetry;
3250 } else { /* decode response */
3251 /* BB remember to free buffer if error BB */
3252 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3253 if(rc == 0) {
3254 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3255 psrch_inf->unicode = TRUE;
3256 else
3257 psrch_inf->unicode = FALSE;
3258
3259 psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3260 psrch_inf->smallBuf = 0;
3261 psrch_inf->srch_entries_start =
3262 (char *) &pSMBr->hdr.Protocol +
3263 le16_to_cpu(pSMBr->t2.DataOffset);
3264 parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3265 le16_to_cpu(pSMBr->t2.ParameterOffset));
3266
3267 if(parms->EndofSearch)
3268 psrch_inf->endOfSearch = TRUE;
3269 else
3270 psrch_inf->endOfSearch = FALSE;
3271
3272 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
3273 psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
3274 psrch_inf->entries_in_buffer;
3275 *pnetfid = parms->SearchHandle;
3276 } else {
3277 cifs_buf_release(pSMB);
3278 }
3279 }
3280
3281 return rc;
3282 }
3283
3284 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3285 __u16 searchHandle, struct cifs_search_info * psrch_inf)
3286 {
3287 TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3288 TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3289 T2_FNEXT_RSP_PARMS * parms;
3290 char *response_data;
3291 int rc = 0;
3292 int bytes_returned, name_len;
3293 __u16 params, byte_count;
3294
3295 cFYI(1, ("In FindNext"));
3296
3297 if(psrch_inf->endOfSearch == TRUE)
3298 return -ENOENT;
3299
3300 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3301 (void **) &pSMBr);
3302 if (rc)
3303 return rc;
3304
3305 params = 14; /* includes 2 bytes of null string, converted to LE below */
3306 byte_count = 0;
3307 pSMB->TotalDataCount = 0; /* no EAs */
3308 pSMB->MaxParameterCount = cpu_to_le16(8);
3309 pSMB->MaxDataCount =
3310 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3311 pSMB->MaxSetupCount = 0;
3312 pSMB->Reserved = 0;
3313 pSMB->Flags = 0;
3314 pSMB->Timeout = 0;
3315 pSMB->Reserved2 = 0;
3316 pSMB->ParameterOffset = cpu_to_le16(
3317 offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3318 pSMB->DataCount = 0;
3319 pSMB->DataOffset = 0;
3320 pSMB->SetupCount = 1;
3321 pSMB->Reserved3 = 0;
3322 pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3323 pSMB->SearchHandle = searchHandle; /* always kept as le */
3324 pSMB->SearchCount =
3325 cpu_to_le16(CIFSMaxBufSize / sizeof (FILE_UNIX_INFO));
3326 /* test for Unix extensions */
3327 /* if (tcon->ses->capabilities & CAP_UNIX) {
3328 pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_UNIX);
3329 psrch_inf->info_level = SMB_FIND_FILE_UNIX;
3330 } else {
3331 pSMB->InformationLevel =
3332 cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
3333 psrch_inf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
3334 } */
3335 pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3336 pSMB->ResumeKey = psrch_inf->resume_key;
3337 pSMB->SearchFlags =
3338 cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3339
3340 name_len = psrch_inf->resume_name_len;
3341 params += name_len;
3342 if(name_len < PATH_MAX) {
3343 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3344 byte_count += name_len;
3345 /* 14 byte parm len above enough for 2 byte null terminator */
3346 pSMB->ResumeFileName[name_len] = 0;
3347 pSMB->ResumeFileName[name_len+1] = 0;
3348 } else {
3349 rc = -EINVAL;
3350 goto FNext2_err_exit;
3351 }
3352 byte_count = params + 1 /* pad */ ;
3353 pSMB->TotalParameterCount = cpu_to_le16(params);
3354 pSMB->ParameterCount = pSMB->TotalParameterCount;
3355 pSMB->hdr.smb_buf_length += byte_count;
3356 pSMB->ByteCount = cpu_to_le16(byte_count);
3357
3358 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3359 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3360 cifs_stats_inc(&tcon->num_fnext);
3361 if (rc) {
3362 if (rc == -EBADF) {
3363 psrch_inf->endOfSearch = TRUE;
3364 rc = 0; /* search probably was closed at end of search above */
3365 } else
3366 cFYI(1, ("FindNext returned = %d", rc));
3367 } else { /* decode response */
3368 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3369
3370 if(rc == 0) {
3371 /* BB fixme add lock for file (srch_info) struct here */
3372 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3373 psrch_inf->unicode = TRUE;
3374 else
3375 psrch_inf->unicode = FALSE;
3376 response_data = (char *) &pSMBr->hdr.Protocol +
3377 le16_to_cpu(pSMBr->t2.ParameterOffset);
3378 parms = (T2_FNEXT_RSP_PARMS *)response_data;
3379 response_data = (char *)&pSMBr->hdr.Protocol +
3380 le16_to_cpu(pSMBr->t2.DataOffset);
3381 if(psrch_inf->smallBuf)
3382 cifs_small_buf_release(
3383 psrch_inf->ntwrk_buf_start);
3384 else
3385 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3386 psrch_inf->srch_entries_start = response_data;
3387 psrch_inf->ntwrk_buf_start = (char *)pSMB;
3388 psrch_inf->smallBuf = 0;
3389 if(parms->EndofSearch)
3390 psrch_inf->endOfSearch = TRUE;
3391 else
3392 psrch_inf->endOfSearch = FALSE;
3393
3394 psrch_inf->entries_in_buffer = le16_to_cpu(parms->SearchCount);
3395 psrch_inf->index_of_last_entry +=
3396 psrch_inf->entries_in_buffer;
3397 /* cFYI(1,("fnxt2 entries in buf %d index_of_last %d",psrch_inf->entries_in_buffer,psrch_inf->index_of_last_entry)); */
3398
3399 /* BB fixme add unlock here */
3400 }
3401
3402 }
3403
3404 /* BB On error, should we leave previous search buf (and count and
3405 last entry fields) intact or free the previous one? */
3406
3407 /* Note: On -EAGAIN error only caller can retry on handle based calls
3408 since file handle passed in no longer valid */
3409 FNext2_err_exit:
3410 if (rc != 0)
3411 cifs_buf_release(pSMB);
3412
3413 return rc;
3414 }
3415
3416 int
3417 CIFSFindClose(const int xid, struct cifsTconInfo *tcon, const __u16 searchHandle)
3418 {
3419 int rc = 0;
3420 FINDCLOSE_REQ *pSMB = NULL;
3421 CLOSE_RSP *pSMBr = NULL; /* BB removeme BB */
3422 int bytes_returned;
3423
3424 cFYI(1, ("In CIFSSMBFindClose"));
3425 rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3426
3427 /* no sense returning error if session restarted
3428 as file handle has been closed */
3429 if(rc == -EAGAIN)
3430 return 0;
3431 if (rc)
3432 return rc;
3433
3434 pSMBr = (CLOSE_RSP *)pSMB; /* BB removeme BB */
3435 pSMB->FileID = searchHandle;
3436 pSMB->ByteCount = 0;
3437 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3438 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3439 if (rc) {
3440 cERROR(1, ("Send error in FindClose = %d", rc));
3441 }
3442 cifs_stats_inc(&tcon->num_fclose);
3443 cifs_small_buf_release(pSMB);
3444
3445 /* Since session is dead, search handle closed on server already */
3446 if (rc == -EAGAIN)
3447 rc = 0;
3448
3449 return rc;
3450 }
3451
3452 int
3453 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3454 const unsigned char *searchName,
3455 __u64 * inode_number,
3456 const struct nls_table *nls_codepage, int remap)
3457 {
3458 int rc = 0;
3459 TRANSACTION2_QPI_REQ *pSMB = NULL;
3460 TRANSACTION2_QPI_RSP *pSMBr = NULL;
3461 int name_len, bytes_returned;
3462 __u16 params, byte_count;
3463
3464 cFYI(1,("In GetSrvInodeNum for %s",searchName));
3465 if(tcon == NULL)
3466 return -ENODEV;
3467
3468 GetInodeNumberRetry:
3469 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3470 (void **) &pSMBr);
3471 if (rc)
3472 return rc;
3473
3474
3475 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3476 name_len =
3477 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3478 PATH_MAX,nls_codepage, remap);
3479 name_len++; /* trailing null */
3480 name_len *= 2;
3481 } else { /* BB improve the check for buffer overruns BB */
3482 name_len = strnlen(searchName, PATH_MAX);
3483 name_len++; /* trailing null */
3484 strncpy(pSMB->FileName, searchName, name_len);
3485 }
3486
3487 params = 2 /* level */ + 4 /* rsrvd */ + name_len /* incl null */ ;
3488 pSMB->TotalDataCount = 0;
3489 pSMB->MaxParameterCount = cpu_to_le16(2);
3490 /* BB find exact max data count below from sess structure BB */
3491 pSMB->MaxDataCount = cpu_to_le16(4000);
3492 pSMB->MaxSetupCount = 0;
3493 pSMB->Reserved = 0;
3494 pSMB->Flags = 0;
3495 pSMB->Timeout = 0;
3496 pSMB->Reserved2 = 0;
3497 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3498 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
3499 pSMB->DataCount = 0;
3500 pSMB->DataOffset = 0;
3501 pSMB->SetupCount = 1;
3502 pSMB->Reserved3 = 0;
3503 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3504 byte_count = params + 1 /* pad */ ;
3505 pSMB->TotalParameterCount = cpu_to_le16(params);
3506 pSMB->ParameterCount = pSMB->TotalParameterCount;
3507 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3508 pSMB->Reserved4 = 0;
3509 pSMB->hdr.smb_buf_length += byte_count;
3510 pSMB->ByteCount = cpu_to_le16(byte_count);
3511
3512 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3513 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3514 if (rc) {
3515 cFYI(1, ("error %d in QueryInternalInfo", rc));
3516 } else {
3517 /* decode response */
3518 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3519 if (rc || (pSMBr->ByteCount < 2))
3520 /* BB also check enough total bytes returned */
3521 /* If rc should we check for EOPNOSUPP and
3522 disable the srvino flag? or in caller? */
3523 rc = -EIO; /* bad smb */
3524 else {
3525 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3526 __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3527 struct file_internal_info * pfinfo;
3528 /* BB Do we need a cast or hash here ? */
3529 if(count < 8) {
3530 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3531 rc = -EIO;
3532 goto GetInodeNumOut;
3533 }
3534 pfinfo = (struct file_internal_info *)
3535 (data_offset + (char *) &pSMBr->hdr.Protocol);
3536 *inode_number = pfinfo->UniqueId;
3537 }
3538 }
3539 GetInodeNumOut:
3540 cifs_buf_release(pSMB);
3541 if (rc == -EAGAIN)
3542 goto GetInodeNumberRetry;
3543 return rc;
3544 }
3545
3546 int
3547 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3548 const unsigned char *searchName,
3549 unsigned char **targetUNCs,
3550 unsigned int *number_of_UNC_in_array,
3551 const struct nls_table *nls_codepage, int remap)
3552 {
3553 /* TRANS2_GET_DFS_REFERRAL */
3554 TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
3555 TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
3556 struct dfs_referral_level_3 * referrals = NULL;
3557 int rc = 0;
3558 int bytes_returned;
3559 int name_len;
3560 unsigned int i;
3561 char * temp;
3562 __u16 params, byte_count;
3563 *number_of_UNC_in_array = 0;
3564 *targetUNCs = NULL;
3565
3566 cFYI(1, ("In GetDFSRefer the path %s", searchName));
3567 if (ses == NULL)
3568 return -ENODEV;
3569 getDFSRetry:
3570 rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
3571 (void **) &pSMBr);
3572 if (rc)
3573 return rc;
3574
3575 /* server pointer checked in called function,
3576 but should never be null here anyway */
3577 pSMB->hdr.Mid = GetNextMid(ses->server);
3578 pSMB->hdr.Tid = ses->ipc_tid;
3579 pSMB->hdr.Uid = ses->Suid;
3580 if (ses->capabilities & CAP_STATUS32) {
3581 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
3582 }
3583 if (ses->capabilities & CAP_DFS) {
3584 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
3585 }
3586
3587 if (ses->capabilities & CAP_UNICODE) {
3588 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
3589 name_len =
3590 cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
3591 searchName, PATH_MAX, nls_codepage, remap);
3592 name_len++; /* trailing null */
3593 name_len *= 2;
3594 } else { /* BB improve the check for buffer overruns BB */
3595 name_len = strnlen(searchName, PATH_MAX);
3596 name_len++; /* trailing null */
3597 strncpy(pSMB->RequestFileName, searchName, name_len);
3598 }
3599
3600 params = 2 /* level */ + name_len /*includes null */ ;
3601 pSMB->TotalDataCount = 0;
3602 pSMB->DataCount = 0;
3603 pSMB->DataOffset = 0;
3604 pSMB->MaxParameterCount = 0;
3605 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3606 pSMB->MaxSetupCount = 0;
3607 pSMB->Reserved = 0;
3608 pSMB->Flags = 0;
3609 pSMB->Timeout = 0;
3610 pSMB->Reserved2 = 0;
3611 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3612 struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
3613 pSMB->SetupCount = 1;
3614 pSMB->Reserved3 = 0;
3615 pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
3616 byte_count = params + 3 /* pad */ ;
3617 pSMB->ParameterCount = cpu_to_le16(params);
3618 pSMB->TotalParameterCount = pSMB->ParameterCount;
3619 pSMB->MaxReferralLevel = cpu_to_le16(3);
3620 pSMB->hdr.smb_buf_length += byte_count;
3621 pSMB->ByteCount = cpu_to_le16(byte_count);
3622
3623 rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
3624 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3625 if (rc) {
3626 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
3627 } else { /* decode response */
3628 /* BB Add logic to parse referrals here */
3629 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3630
3631 if (rc || (pSMBr->ByteCount < 17)) /* BB also check enough total bytes returned */
3632 rc = -EIO; /* bad smb */
3633 else {
3634 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3635 __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
3636
3637 cFYI(1,
3638 ("Decoding GetDFSRefer response. BCC: %d Offset %d",
3639 pSMBr->ByteCount, data_offset));
3640 referrals =
3641 (struct dfs_referral_level_3 *)
3642 (8 /* sizeof start of data block */ +
3643 data_offset +
3644 (char *) &pSMBr->hdr.Protocol);
3645 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",
3646 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)));
3647 /* BB This field is actually two bytes in from start of
3648 data block so we could do safety check that DataBlock
3649 begins at address of pSMBr->NumberOfReferrals */
3650 *number_of_UNC_in_array = le16_to_cpu(pSMBr->NumberOfReferrals);
3651
3652 /* BB Fix below so can return more than one referral */
3653 if(*number_of_UNC_in_array > 1)
3654 *number_of_UNC_in_array = 1;
3655
3656 /* get the length of the strings describing refs */
3657 name_len = 0;
3658 for(i=0;i<*number_of_UNC_in_array;i++) {
3659 /* make sure that DfsPathOffset not past end */
3660 __u16 offset = le16_to_cpu(referrals->DfsPathOffset);
3661 if (offset > data_count) {
3662 /* if invalid referral, stop here and do
3663 not try to copy any more */
3664 *number_of_UNC_in_array = i;
3665 break;
3666 }
3667 temp = ((char *)referrals) + offset;
3668
3669 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3670 name_len += UniStrnlen((wchar_t *)temp,data_count);
3671 } else {
3672 name_len += strnlen(temp,data_count);
3673 }
3674 referrals++;
3675 /* BB add check that referral pointer does not fall off end PDU */
3676
3677 }
3678 /* BB add check for name_len bigger than bcc */
3679 *targetUNCs =
3680 kmalloc(name_len+1+ (*number_of_UNC_in_array),GFP_KERNEL);
3681 if(*targetUNCs == NULL) {
3682 rc = -ENOMEM;
3683 goto GetDFSRefExit;
3684 }
3685 /* copy the ref strings */
3686 referrals =
3687 (struct dfs_referral_level_3 *)
3688 (8 /* sizeof data hdr */ +
3689 data_offset +
3690 (char *) &pSMBr->hdr.Protocol);
3691
3692 for(i=0;i<*number_of_UNC_in_array;i++) {
3693 temp = ((char *)referrals) + le16_to_cpu(referrals->DfsPathOffset);
3694 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
3695 cifs_strfromUCS_le(*targetUNCs,
3696 (__le16 *) temp, name_len, nls_codepage);
3697 } else {
3698 strncpy(*targetUNCs,temp,name_len);
3699 }
3700 /* BB update target_uncs pointers */
3701 referrals++;
3702 }
3703 temp = *targetUNCs;
3704 temp[name_len] = 0;
3705 }
3706
3707 }
3708 GetDFSRefExit:
3709 if (pSMB)
3710 cifs_buf_release(pSMB);
3711
3712 if (rc == -EAGAIN)
3713 goto getDFSRetry;
3714
3715 return rc;
3716 }
3717
3718 /* Query File System Info such as free space to old servers such as Win 9x */
3719 int
3720 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
3721 {
3722 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
3723 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3724 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3725 FILE_SYSTEM_ALLOC_INFO *response_data;
3726 int rc = 0;
3727 int bytes_returned = 0;
3728 __u16 params, byte_count;
3729
3730 cFYI(1, ("OldQFSInfo"));
3731 oldQFSInfoRetry:
3732 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3733 (void **) &pSMBr);
3734 if (rc)
3735 return rc;
3736 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3737 (void **) &pSMBr);
3738 if (rc)
3739 return rc;
3740
3741 params = 2; /* level */
3742 pSMB->TotalDataCount = 0;
3743 pSMB->MaxParameterCount = cpu_to_le16(2);
3744 pSMB->MaxDataCount = cpu_to_le16(1000);
3745 pSMB->MaxSetupCount = 0;
3746 pSMB->Reserved = 0;
3747 pSMB->Flags = 0;
3748 pSMB->Timeout = 0;
3749 pSMB->Reserved2 = 0;
3750 byte_count = params + 1 /* pad */ ;
3751 pSMB->TotalParameterCount = cpu_to_le16(params);
3752 pSMB->ParameterCount = pSMB->TotalParameterCount;
3753 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3754 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3755 pSMB->DataCount = 0;
3756 pSMB->DataOffset = 0;
3757 pSMB->SetupCount = 1;
3758 pSMB->Reserved3 = 0;
3759 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3760 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
3761 pSMB->hdr.smb_buf_length += byte_count;
3762 pSMB->ByteCount = cpu_to_le16(byte_count);
3763
3764 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3765 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3766 if (rc) {
3767 cFYI(1, ("Send error in QFSInfo = %d", rc));
3768 } else { /* decode response */
3769 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3770
3771 if (rc || (pSMBr->ByteCount < 18))
3772 rc = -EIO; /* bad smb */
3773 else {
3774 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3775 cFYI(1,("qfsinf resp BCC: %d Offset %d",
3776 pSMBr->ByteCount, data_offset));
3777
3778 response_data =
3779 (FILE_SYSTEM_ALLOC_INFO *)
3780 (((char *) &pSMBr->hdr.Protocol) + data_offset);
3781 FSData->f_bsize =
3782 le16_to_cpu(response_data->BytesPerSector) *
3783 le32_to_cpu(response_data->
3784 SectorsPerAllocationUnit);
3785 FSData->f_blocks =
3786 le32_to_cpu(response_data->TotalAllocationUnits);
3787 FSData->f_bfree = FSData->f_bavail =
3788 le32_to_cpu(response_data->FreeAllocationUnits);
3789 cFYI(1,
3790 ("Blocks: %lld Free: %lld Block size %ld",
3791 (unsigned long long)FSData->f_blocks,
3792 (unsigned long long)FSData->f_bfree,
3793 FSData->f_bsize));
3794 }
3795 }
3796 cifs_buf_release(pSMB);
3797
3798 if (rc == -EAGAIN)
3799 goto oldQFSInfoRetry;
3800
3801 return rc;
3802 }
3803
3804 int
3805 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
3806 {
3807 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
3808 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3809 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3810 FILE_SYSTEM_INFO *response_data;
3811 int rc = 0;
3812 int bytes_returned = 0;
3813 __u16 params, byte_count;
3814
3815 cFYI(1, ("In QFSInfo"));
3816 QFSInfoRetry:
3817 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3818 (void **) &pSMBr);
3819 if (rc)
3820 return rc;
3821
3822 params = 2; /* level */
3823 pSMB->TotalDataCount = 0;
3824 pSMB->MaxParameterCount = cpu_to_le16(2);
3825 pSMB->MaxDataCount = cpu_to_le16(1000);
3826 pSMB->MaxSetupCount = 0;
3827 pSMB->Reserved = 0;
3828 pSMB->Flags = 0;
3829 pSMB->Timeout = 0;
3830 pSMB->Reserved2 = 0;
3831 byte_count = params + 1 /* pad */ ;
3832 pSMB->TotalParameterCount = cpu_to_le16(params);
3833 pSMB->ParameterCount = pSMB->TotalParameterCount;
3834 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3835 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3836 pSMB->DataCount = 0;
3837 pSMB->DataOffset = 0;
3838 pSMB->SetupCount = 1;
3839 pSMB->Reserved3 = 0;
3840 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3841 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
3842 pSMB->hdr.smb_buf_length += byte_count;
3843 pSMB->ByteCount = cpu_to_le16(byte_count);
3844
3845 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3846 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3847 if (rc) {
3848 cFYI(1, ("Send error in QFSInfo = %d", rc));
3849 } else { /* decode response */
3850 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3851
3852 if (rc || (pSMBr->ByteCount < 24))
3853 rc = -EIO; /* bad smb */
3854 else {
3855 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3856
3857 response_data =
3858 (FILE_SYSTEM_INFO
3859 *) (((char *) &pSMBr->hdr.Protocol) +
3860 data_offset);
3861 FSData->f_bsize =
3862 le32_to_cpu(response_data->BytesPerSector) *
3863 le32_to_cpu(response_data->
3864 SectorsPerAllocationUnit);
3865 FSData->f_blocks =
3866 le64_to_cpu(response_data->TotalAllocationUnits);
3867 FSData->f_bfree = FSData->f_bavail =
3868 le64_to_cpu(response_data->FreeAllocationUnits);
3869 cFYI(1,
3870 ("Blocks: %lld Free: %lld Block size %ld",
3871 (unsigned long long)FSData->f_blocks,
3872 (unsigned long long)FSData->f_bfree,
3873 FSData->f_bsize));
3874 }
3875 }
3876 cifs_buf_release(pSMB);
3877
3878 if (rc == -EAGAIN)
3879 goto QFSInfoRetry;
3880
3881 return rc;
3882 }
3883
3884 int
3885 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
3886 {
3887 /* level 0x105 SMB_QUERY_FILE_SYSTEM_INFO */
3888 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3889 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3890 FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
3891 int rc = 0;
3892 int bytes_returned = 0;
3893 __u16 params, byte_count;
3894
3895 cFYI(1, ("In QFSAttributeInfo"));
3896 QFSAttributeRetry:
3897 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3898 (void **) &pSMBr);
3899 if (rc)
3900 return rc;
3901
3902 params = 2; /* level */
3903 pSMB->TotalDataCount = 0;
3904 pSMB->MaxParameterCount = cpu_to_le16(2);
3905 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3906 pSMB->MaxSetupCount = 0;
3907 pSMB->Reserved = 0;
3908 pSMB->Flags = 0;
3909 pSMB->Timeout = 0;
3910 pSMB->Reserved2 = 0;
3911 byte_count = params + 1 /* pad */ ;
3912 pSMB->TotalParameterCount = cpu_to_le16(params);
3913 pSMB->ParameterCount = pSMB->TotalParameterCount;
3914 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3915 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3916 pSMB->DataCount = 0;
3917 pSMB->DataOffset = 0;
3918 pSMB->SetupCount = 1;
3919 pSMB->Reserved3 = 0;
3920 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3921 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
3922 pSMB->hdr.smb_buf_length += byte_count;
3923 pSMB->ByteCount = cpu_to_le16(byte_count);
3924
3925 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3926 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3927 if (rc) {
3928 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
3929 } else { /* decode response */
3930 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3931
3932 if (rc || (pSMBr->ByteCount < 13)) { /* BB also check enough bytes returned */
3933 rc = -EIO; /* bad smb */
3934 } else {
3935 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3936 response_data =
3937 (FILE_SYSTEM_ATTRIBUTE_INFO
3938 *) (((char *) &pSMBr->hdr.Protocol) +
3939 data_offset);
3940 memcpy(&tcon->fsAttrInfo, response_data,
3941 sizeof (FILE_SYSTEM_ATTRIBUTE_INFO));
3942 }
3943 }
3944 cifs_buf_release(pSMB);
3945
3946 if (rc == -EAGAIN)
3947 goto QFSAttributeRetry;
3948
3949 return rc;
3950 }
3951
3952 int
3953 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
3954 {
3955 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
3956 TRANSACTION2_QFSI_REQ *pSMB = NULL;
3957 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
3958 FILE_SYSTEM_DEVICE_INFO *response_data;
3959 int rc = 0;
3960 int bytes_returned = 0;
3961 __u16 params, byte_count;
3962
3963 cFYI(1, ("In QFSDeviceInfo"));
3964 QFSDeviceRetry:
3965 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3966 (void **) &pSMBr);
3967 if (rc)
3968 return rc;
3969
3970 params = 2; /* level */
3971 pSMB->TotalDataCount = 0;
3972 pSMB->MaxParameterCount = cpu_to_le16(2);
3973 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
3974 pSMB->MaxSetupCount = 0;
3975 pSMB->Reserved = 0;
3976 pSMB->Flags = 0;
3977 pSMB->Timeout = 0;
3978 pSMB->Reserved2 = 0;
3979 byte_count = params + 1 /* pad */ ;
3980 pSMB->TotalParameterCount = cpu_to_le16(params);
3981 pSMB->ParameterCount = pSMB->TotalParameterCount;
3982 pSMB->ParameterOffset = cpu_to_le16(offsetof(
3983 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
3984
3985 pSMB->DataCount = 0;
3986 pSMB->DataOffset = 0;
3987 pSMB->SetupCount = 1;
3988 pSMB->Reserved3 = 0;
3989 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
3990 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
3991 pSMB->hdr.smb_buf_length += byte_count;
3992 pSMB->ByteCount = cpu_to_le16(byte_count);
3993
3994 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3995 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3996 if (rc) {
3997 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
3998 } else { /* decode response */
3999 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4000
4001 if (rc || (pSMBr->ByteCount < sizeof (FILE_SYSTEM_DEVICE_INFO)))
4002 rc = -EIO; /* bad smb */
4003 else {
4004 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4005 response_data =
4006 (FILE_SYSTEM_DEVICE_INFO *)
4007 (((char *) &pSMBr->hdr.Protocol) +
4008 data_offset);
4009 memcpy(&tcon->fsDevInfo, response_data,
4010 sizeof (FILE_SYSTEM_DEVICE_INFO));
4011 }
4012 }
4013 cifs_buf_release(pSMB);
4014
4015 if (rc == -EAGAIN)
4016 goto QFSDeviceRetry;
4017
4018 return rc;
4019 }
4020
4021 int
4022 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
4023 {
4024 /* level 0x200 SMB_QUERY_CIFS_UNIX_INFO */
4025 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4026 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4027 FILE_SYSTEM_UNIX_INFO *response_data;
4028 int rc = 0;
4029 int bytes_returned = 0;
4030 __u16 params, byte_count;
4031
4032 cFYI(1, ("In QFSUnixInfo"));
4033 QFSUnixRetry:
4034 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4035 (void **) &pSMBr);
4036 if (rc)
4037 return rc;
4038
4039 params = 2; /* level */
4040 pSMB->TotalDataCount = 0;
4041 pSMB->DataCount = 0;
4042 pSMB->DataOffset = 0;
4043 pSMB->MaxParameterCount = cpu_to_le16(2);
4044 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4045 pSMB->MaxSetupCount = 0;
4046 pSMB->Reserved = 0;
4047 pSMB->Flags = 0;
4048 pSMB->Timeout = 0;
4049 pSMB->Reserved2 = 0;
4050 byte_count = params + 1 /* pad */ ;
4051 pSMB->ParameterCount = cpu_to_le16(params);
4052 pSMB->TotalParameterCount = pSMB->ParameterCount;
4053 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4054 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4055 pSMB->SetupCount = 1;
4056 pSMB->Reserved3 = 0;
4057 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4058 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4059 pSMB->hdr.smb_buf_length += byte_count;
4060 pSMB->ByteCount = cpu_to_le16(byte_count);
4061
4062 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4063 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4064 if (rc) {
4065 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
4066 } else { /* decode response */
4067 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4068
4069 if (rc || (pSMBr->ByteCount < 13)) {
4070 rc = -EIO; /* bad smb */
4071 } else {
4072 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4073 response_data =
4074 (FILE_SYSTEM_UNIX_INFO
4075 *) (((char *) &pSMBr->hdr.Protocol) +
4076 data_offset);
4077 memcpy(&tcon->fsUnixInfo, response_data,
4078 sizeof (FILE_SYSTEM_UNIX_INFO));
4079 }
4080 }
4081 cifs_buf_release(pSMB);
4082
4083 if (rc == -EAGAIN)
4084 goto QFSUnixRetry;
4085
4086
4087 return rc;
4088 }
4089
4090 int
4091 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
4092 {
4093 /* level 0x200 SMB_SET_CIFS_UNIX_INFO */
4094 TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4095 TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4096 int rc = 0;
4097 int bytes_returned = 0;
4098 __u16 params, param_offset, offset, byte_count;
4099
4100 cFYI(1, ("In SETFSUnixInfo"));
4101 SETFSUnixRetry:
4102 /* BB switch to small buf init to save memory */
4103 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4104 (void **) &pSMBr);
4105 if (rc)
4106 return rc;
4107
4108 params = 4; /* 2 bytes zero followed by info level. */
4109 pSMB->MaxSetupCount = 0;
4110 pSMB->Reserved = 0;
4111 pSMB->Flags = 0;
4112 pSMB->Timeout = 0;
4113 pSMB->Reserved2 = 0;
4114 param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum) - 4;
4115 offset = param_offset + params;
4116
4117 pSMB->MaxParameterCount = cpu_to_le16(4);
4118 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4119 pSMB->SetupCount = 1;
4120 pSMB->Reserved3 = 0;
4121 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4122 byte_count = 1 /* pad */ + params + 12;
4123
4124 pSMB->DataCount = cpu_to_le16(12);
4125 pSMB->ParameterCount = cpu_to_le16(params);
4126 pSMB->TotalDataCount = pSMB->DataCount;
4127 pSMB->TotalParameterCount = pSMB->ParameterCount;
4128 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4129 pSMB->DataOffset = cpu_to_le16(offset);
4130
4131 /* Params. */
4132 pSMB->FileNum = 0;
4133 pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4134
4135 /* Data. */
4136 pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4137 pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4138 pSMB->ClientUnixCap = cpu_to_le64(cap);
4139
4140 pSMB->hdr.smb_buf_length += byte_count;
4141 pSMB->ByteCount = cpu_to_le16(byte_count);
4142
4143 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4144 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4145 if (rc) {
4146 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
4147 } else { /* decode response */
4148 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4149 if (rc) {
4150 rc = -EIO; /* bad smb */
4151 }
4152 }
4153 cifs_buf_release(pSMB);
4154
4155 if (rc == -EAGAIN)
4156 goto SETFSUnixRetry;
4157
4158 return rc;
4159 }
4160
4161
4162
4163 int
4164 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
4165 struct kstatfs *FSData)
4166 {
4167 /* level 0x201 SMB_QUERY_CIFS_POSIX_INFO */
4168 TRANSACTION2_QFSI_REQ *pSMB = NULL;
4169 TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4170 FILE_SYSTEM_POSIX_INFO *response_data;
4171 int rc = 0;
4172 int bytes_returned = 0;
4173 __u16 params, byte_count;
4174
4175 cFYI(1, ("In QFSPosixInfo"));
4176 QFSPosixRetry:
4177 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4178 (void **) &pSMBr);
4179 if (rc)
4180 return rc;
4181
4182 params = 2; /* level */
4183 pSMB->TotalDataCount = 0;
4184 pSMB->DataCount = 0;
4185 pSMB->DataOffset = 0;
4186 pSMB->MaxParameterCount = cpu_to_le16(2);
4187 pSMB->MaxDataCount = cpu_to_le16(100); /* BB find exact max SMB PDU from sess structure BB */
4188 pSMB->MaxSetupCount = 0;
4189 pSMB->Reserved = 0;
4190 pSMB->Flags = 0;
4191 pSMB->Timeout = 0;
4192 pSMB->Reserved2 = 0;
4193 byte_count = params + 1 /* pad */ ;
4194 pSMB->ParameterCount = cpu_to_le16(params);
4195 pSMB->TotalParameterCount = pSMB->ParameterCount;
4196 pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4197 smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4198 pSMB->SetupCount = 1;
4199 pSMB->Reserved3 = 0;
4200 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4201 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4202 pSMB->hdr.smb_buf_length += byte_count;
4203 pSMB->ByteCount = cpu_to_le16(byte_count);
4204
4205 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4206 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4207 if (rc) {
4208 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
4209 } else { /* decode response */
4210 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4211
4212 if (rc || (pSMBr->ByteCount < 13)) {
4213 rc = -EIO; /* bad smb */
4214 } else {
4215 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4216 response_data =
4217 (FILE_SYSTEM_POSIX_INFO
4218 *) (((char *) &pSMBr->hdr.Protocol) +
4219 data_offset);
4220 FSData->f_bsize =
4221 le32_to_cpu(response_data->BlockSize);
4222 FSData->f_blocks =
4223 le64_to_cpu(response_data->TotalBlocks);
4224 FSData->f_bfree =
4225 le64_to_cpu(response_data->BlocksAvail);
4226 if(response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4227 FSData->f_bavail = FSData->f_bfree;
4228 } else {
4229 FSData->f_bavail =
4230 le64_to_cpu(response_data->UserBlocksAvail);
4231 }
4232 if(response_data->TotalFileNodes != cpu_to_le64(-1))
4233 FSData->f_files =
4234 le64_to_cpu(response_data->TotalFileNodes);
4235 if(response_data->FreeFileNodes != cpu_to_le64(-1))
4236 FSData->f_ffree =
4237 le64_to_cpu(response_data->FreeFileNodes);
4238 }
4239 }
4240 cifs_buf_release(pSMB);
4241
4242 if (rc == -EAGAIN)
4243 goto QFSPosixRetry;
4244
4245 return rc;
4246 }
4247
4248
4249 /* We can not use write of zero bytes trick to
4250 set file size due to need for large file support. Also note that
4251 this SetPathInfo is preferred to SetFileInfo based method in next
4252 routine which is only needed to work around a sharing violation bug
4253 in Samba which this routine can run into */
4254
4255 int
4256 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4257 __u64 size, int SetAllocation,
4258 const struct nls_table *nls_codepage, int remap)
4259 {
4260 struct smb_com_transaction2_spi_req *pSMB = NULL;
4261 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4262 struct file_end_of_file_info *parm_data;
4263 int name_len;
4264 int rc = 0;
4265 int bytes_returned = 0;
4266 __u16 params, byte_count, data_count, param_offset, offset;
4267
4268 cFYI(1, ("In SetEOF"));
4269 SetEOFRetry:
4270 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4271 (void **) &pSMBr);
4272 if (rc)
4273 return rc;
4274
4275 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4276 name_len =
4277 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4278 PATH_MAX, nls_codepage, remap);
4279 name_len++; /* trailing null */
4280 name_len *= 2;
4281 } else { /* BB improve the check for buffer overruns BB */
4282 name_len = strnlen(fileName, PATH_MAX);
4283 name_len++; /* trailing null */
4284 strncpy(pSMB->FileName, fileName, name_len);
4285 }
4286 params = 6 + name_len;
4287 data_count = sizeof (struct file_end_of_file_info);
4288 pSMB->MaxParameterCount = cpu_to_le16(2);
4289 pSMB->MaxDataCount = cpu_to_le16(4100);
4290 pSMB->MaxSetupCount = 0;
4291 pSMB->Reserved = 0;
4292 pSMB->Flags = 0;
4293 pSMB->Timeout = 0;
4294 pSMB->Reserved2 = 0;
4295 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4296 InformationLevel) - 4;
4297 offset = param_offset + params;
4298 if(SetAllocation) {
4299 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4300 pSMB->InformationLevel =
4301 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4302 else
4303 pSMB->InformationLevel =
4304 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4305 } else /* Set File Size */ {
4306 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4307 pSMB->InformationLevel =
4308 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4309 else
4310 pSMB->InformationLevel =
4311 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4312 }
4313
4314 parm_data =
4315 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4316 offset);
4317 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4318 pSMB->DataOffset = cpu_to_le16(offset);
4319 pSMB->SetupCount = 1;
4320 pSMB->Reserved3 = 0;
4321 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4322 byte_count = 3 /* pad */ + params + data_count;
4323 pSMB->DataCount = cpu_to_le16(data_count);
4324 pSMB->TotalDataCount = pSMB->DataCount;
4325 pSMB->ParameterCount = cpu_to_le16(params);
4326 pSMB->TotalParameterCount = pSMB->ParameterCount;
4327 pSMB->Reserved4 = 0;
4328 pSMB->hdr.smb_buf_length += byte_count;
4329 parm_data->FileSize = cpu_to_le64(size);
4330 pSMB->ByteCount = cpu_to_le16(byte_count);
4331 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4332 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4333 if (rc) {
4334 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4335 }
4336
4337 cifs_buf_release(pSMB);
4338
4339 if (rc == -EAGAIN)
4340 goto SetEOFRetry;
4341
4342 return rc;
4343 }
4344
4345 int
4346 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4347 __u16 fid, __u32 pid_of_opener, int SetAllocation)
4348 {
4349 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4350 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4351 char *data_offset;
4352 struct file_end_of_file_info *parm_data;
4353 int rc = 0;
4354 int bytes_returned = 0;
4355 __u16 params, param_offset, offset, byte_count, count;
4356
4357 cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4358 (long long)size));
4359 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4360
4361 if (rc)
4362 return rc;
4363
4364 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4365
4366 pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4367 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4368
4369 params = 6;
4370 pSMB->MaxSetupCount = 0;
4371 pSMB->Reserved = 0;
4372 pSMB->Flags = 0;
4373 pSMB->Timeout = 0;
4374 pSMB->Reserved2 = 0;
4375 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4376 offset = param_offset + params;
4377
4378 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4379
4380 count = sizeof(struct file_end_of_file_info);
4381 pSMB->MaxParameterCount = cpu_to_le16(2);
4382 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4383 pSMB->SetupCount = 1;
4384 pSMB->Reserved3 = 0;
4385 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4386 byte_count = 3 /* pad */ + params + count;
4387 pSMB->DataCount = cpu_to_le16(count);
4388 pSMB->ParameterCount = cpu_to_le16(params);
4389 pSMB->TotalDataCount = pSMB->DataCount;
4390 pSMB->TotalParameterCount = pSMB->ParameterCount;
4391 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4392 parm_data =
4393 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4394 offset);
4395 pSMB->DataOffset = cpu_to_le16(offset);
4396 parm_data->FileSize = cpu_to_le64(size);
4397 pSMB->Fid = fid;
4398 if(SetAllocation) {
4399 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4400 pSMB->InformationLevel =
4401 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4402 else
4403 pSMB->InformationLevel =
4404 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4405 } else /* Set File Size */ {
4406 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4407 pSMB->InformationLevel =
4408 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4409 else
4410 pSMB->InformationLevel =
4411 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4412 }
4413 pSMB->Reserved4 = 0;
4414 pSMB->hdr.smb_buf_length += byte_count;
4415 pSMB->ByteCount = cpu_to_le16(byte_count);
4416 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4417 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4418 if (rc) {
4419 cFYI(1,
4420 ("Send error in SetFileInfo (SetFileSize) = %d",
4421 rc));
4422 }
4423
4424 if (pSMB)
4425 cifs_small_buf_release(pSMB);
4426
4427 /* Note: On -EAGAIN error only caller can retry on handle based calls
4428 since file handle passed in no longer valid */
4429
4430 return rc;
4431 }
4432
4433 /* Some legacy servers such as NT4 require that the file times be set on
4434 an open handle, rather than by pathname - this is awkward due to
4435 potential access conflicts on the open, but it is unavoidable for these
4436 old servers since the only other choice is to go from 100 nanosecond DCE
4437 time and resort to the original setpathinfo level which takes the ancient
4438 DOS time format with 2 second granularity */
4439 int
4440 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon, const FILE_BASIC_INFO * data,
4441 __u16 fid)
4442 {
4443 struct smb_com_transaction2_sfi_req *pSMB = NULL;
4444 struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
4445 char *data_offset;
4446 int rc = 0;
4447 int bytes_returned = 0;
4448 __u16 params, param_offset, offset, byte_count, count;
4449
4450 cFYI(1, ("Set Times (via SetFileInfo)"));
4451 rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4452
4453 if (rc)
4454 return rc;
4455
4456 pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
4457
4458 /* At this point there is no need to override the current pid
4459 with the pid of the opener, but that could change if we someday
4460 use an existing handle (rather than opening one on the fly) */
4461 /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4462 pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
4463
4464 params = 6;
4465 pSMB->MaxSetupCount = 0;
4466 pSMB->Reserved = 0;
4467 pSMB->Flags = 0;
4468 pSMB->Timeout = 0;
4469 pSMB->Reserved2 = 0;
4470 param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4471 offset = param_offset + params;
4472
4473 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4474
4475 count = sizeof (FILE_BASIC_INFO);
4476 pSMB->MaxParameterCount = cpu_to_le16(2);
4477 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4478 pSMB->SetupCount = 1;
4479 pSMB->Reserved3 = 0;
4480 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4481 byte_count = 3 /* pad */ + params + count;
4482 pSMB->DataCount = cpu_to_le16(count);
4483 pSMB->ParameterCount = cpu_to_le16(params);
4484 pSMB->TotalDataCount = pSMB->DataCount;
4485 pSMB->TotalParameterCount = pSMB->ParameterCount;
4486 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4487 pSMB->DataOffset = cpu_to_le16(offset);
4488 pSMB->Fid = fid;
4489 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4490 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4491 else
4492 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4493 pSMB->Reserved4 = 0;
4494 pSMB->hdr.smb_buf_length += byte_count;
4495 pSMB->ByteCount = cpu_to_le16(byte_count);
4496 memcpy(data_offset,data,sizeof(FILE_BASIC_INFO));
4497 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4498 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4499 if (rc) {
4500 cFYI(1,("Send error in Set Time (SetFileInfo) = %d",rc));
4501 }
4502
4503 cifs_small_buf_release(pSMB);
4504
4505 /* Note: On -EAGAIN error only caller can retry on handle based calls
4506 since file handle passed in no longer valid */
4507
4508 return rc;
4509 }
4510
4511
4512 int
4513 CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4514 const FILE_BASIC_INFO * data,
4515 const struct nls_table *nls_codepage, int remap)
4516 {
4517 TRANSACTION2_SPI_REQ *pSMB = NULL;
4518 TRANSACTION2_SPI_RSP *pSMBr = NULL;
4519 int name_len;
4520 int rc = 0;
4521 int bytes_returned = 0;
4522 char *data_offset;
4523 __u16 params, param_offset, offset, byte_count, count;
4524
4525 cFYI(1, ("In SetTimes"));
4526
4527 SetTimesRetry:
4528 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4529 (void **) &pSMBr);
4530 if (rc)
4531 return rc;
4532
4533 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4534 name_len =
4535 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4536 PATH_MAX, nls_codepage, remap);
4537 name_len++; /* trailing null */
4538 name_len *= 2;
4539 } else { /* BB improve the check for buffer overruns BB */
4540 name_len = strnlen(fileName, PATH_MAX);
4541 name_len++; /* trailing null */
4542 strncpy(pSMB->FileName, fileName, name_len);
4543 }
4544
4545 params = 6 + name_len;
4546 count = sizeof (FILE_BASIC_INFO);
4547 pSMB->MaxParameterCount = cpu_to_le16(2);
4548 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4549 pSMB->MaxSetupCount = 0;
4550 pSMB->Reserved = 0;
4551 pSMB->Flags = 0;
4552 pSMB->Timeout = 0;
4553 pSMB->Reserved2 = 0;
4554 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4555 InformationLevel) - 4;
4556 offset = param_offset + params;
4557 data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4558 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4559 pSMB->DataOffset = cpu_to_le16(offset);
4560 pSMB->SetupCount = 1;
4561 pSMB->Reserved3 = 0;
4562 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4563 byte_count = 3 /* pad */ + params + count;
4564
4565 pSMB->DataCount = cpu_to_le16(count);
4566 pSMB->ParameterCount = cpu_to_le16(params);
4567 pSMB->TotalDataCount = pSMB->DataCount;
4568 pSMB->TotalParameterCount = pSMB->ParameterCount;
4569 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4570 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4571 else
4572 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4573 pSMB->Reserved4 = 0;
4574 pSMB->hdr.smb_buf_length += byte_count;
4575 memcpy(data_offset, data, sizeof (FILE_BASIC_INFO));
4576 pSMB->ByteCount = cpu_to_le16(byte_count);
4577 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4578 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4579 if (rc) {
4580 cFYI(1, ("SetPathInfo (times) returned %d", rc));
4581 }
4582
4583 cifs_buf_release(pSMB);
4584
4585 if (rc == -EAGAIN)
4586 goto SetTimesRetry;
4587
4588 return rc;
4589 }
4590
4591 /* Can not be used to set time stamps yet (due to old DOS time format) */
4592 /* Can be used to set attributes */
4593 #if 0 /* Possibly not needed - since it turns out that strangely NT4 has a bug
4594 handling it anyway and NT4 was what we thought it would be needed for
4595 Do not delete it until we prove whether needed for Win9x though */
4596 int
4597 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
4598 __u16 dos_attrs, const struct nls_table *nls_codepage)
4599 {
4600 SETATTR_REQ *pSMB = NULL;
4601 SETATTR_RSP *pSMBr = NULL;
4602 int rc = 0;
4603 int bytes_returned;
4604 int name_len;
4605
4606 cFYI(1, ("In SetAttrLegacy"));
4607
4608 SetAttrLgcyRetry:
4609 rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
4610 (void **) &pSMBr);
4611 if (rc)
4612 return rc;
4613
4614 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4615 name_len =
4616 ConvertToUCS((__le16 *) pSMB->fileName, fileName,
4617 PATH_MAX, nls_codepage);
4618 name_len++; /* trailing null */
4619 name_len *= 2;
4620 } else { /* BB improve the check for buffer overruns BB */
4621 name_len = strnlen(fileName, PATH_MAX);
4622 name_len++; /* trailing null */
4623 strncpy(pSMB->fileName, fileName, name_len);
4624 }
4625 pSMB->attr = cpu_to_le16(dos_attrs);
4626 pSMB->BufferFormat = 0x04;
4627 pSMB->hdr.smb_buf_length += name_len + 1;
4628 pSMB->ByteCount = cpu_to_le16(name_len + 1);
4629 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4630 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4631 if (rc) {
4632 cFYI(1, ("Error in LegacySetAttr = %d", rc));
4633 }
4634
4635 cifs_buf_release(pSMB);
4636
4637 if (rc == -EAGAIN)
4638 goto SetAttrLgcyRetry;
4639
4640 return rc;
4641 }
4642 #endif /* temporarily unneeded SetAttr legacy function */
4643
4644 int
4645 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
4646 char *fileName, __u64 mode, __u64 uid, __u64 gid,
4647 dev_t device, const struct nls_table *nls_codepage,
4648 int remap)
4649 {
4650 TRANSACTION2_SPI_REQ *pSMB = NULL;
4651 TRANSACTION2_SPI_RSP *pSMBr = NULL;
4652 int name_len;
4653 int rc = 0;
4654 int bytes_returned = 0;
4655 FILE_UNIX_BASIC_INFO *data_offset;
4656 __u16 params, param_offset, offset, count, byte_count;
4657
4658 cFYI(1, ("In SetUID/GID/Mode"));
4659 setPermsRetry:
4660 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4661 (void **) &pSMBr);
4662 if (rc)
4663 return rc;
4664
4665 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4666 name_len =
4667 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4668 PATH_MAX, nls_codepage, remap);
4669 name_len++; /* trailing null */
4670 name_len *= 2;
4671 } else { /* BB improve the check for buffer overruns BB */
4672 name_len = strnlen(fileName, PATH_MAX);
4673 name_len++; /* trailing null */
4674 strncpy(pSMB->FileName, fileName, name_len);
4675 }
4676
4677 params = 6 + name_len;
4678 count = sizeof (FILE_UNIX_BASIC_INFO);
4679 pSMB->MaxParameterCount = cpu_to_le16(2);
4680 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4681 pSMB->MaxSetupCount = 0;
4682 pSMB->Reserved = 0;
4683 pSMB->Flags = 0;
4684 pSMB->Timeout = 0;
4685 pSMB->Reserved2 = 0;
4686 param_offset = offsetof(struct smb_com_transaction2_spi_req,
4687 InformationLevel) - 4;
4688 offset = param_offset + params;
4689 data_offset =
4690 (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
4691 offset);
4692 memset(data_offset, 0, count);
4693 pSMB->DataOffset = cpu_to_le16(offset);
4694 pSMB->ParameterOffset = cpu_to_le16(param_offset);
4695 pSMB->SetupCount = 1;
4696 pSMB->Reserved3 = 0;
4697 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4698 byte_count = 3 /* pad */ + params + count;
4699 pSMB->ParameterCount = cpu_to_le16(params);
4700 pSMB->DataCount = cpu_to_le16(count);
4701 pSMB->TotalParameterCount = pSMB->ParameterCount;
4702 pSMB->TotalDataCount = pSMB->DataCount;
4703 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
4704 pSMB->Reserved4 = 0;
4705 pSMB->hdr.smb_buf_length += byte_count;
4706 data_offset->Uid = cpu_to_le64(uid);
4707 data_offset->Gid = cpu_to_le64(gid);
4708 /* better to leave device as zero when it is */
4709 data_offset->DevMajor = cpu_to_le64(MAJOR(device));
4710 data_offset->DevMinor = cpu_to_le64(MINOR(device));
4711 data_offset->Permissions = cpu_to_le64(mode);
4712
4713 if(S_ISREG(mode))
4714 data_offset->Type = cpu_to_le32(UNIX_FILE);
4715 else if(S_ISDIR(mode))
4716 data_offset->Type = cpu_to_le32(UNIX_DIR);
4717 else if(S_ISLNK(mode))
4718 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
4719 else if(S_ISCHR(mode))
4720 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
4721 else if(S_ISBLK(mode))
4722 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
4723 else if(S_ISFIFO(mode))
4724 data_offset->Type = cpu_to_le32(UNIX_FIFO);
4725 else if(S_ISSOCK(mode))
4726 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
4727
4728
4729 pSMB->ByteCount = cpu_to_le16(byte_count);
4730 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4731 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4732 if (rc) {
4733 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
4734 }
4735
4736 if (pSMB)
4737 cifs_buf_release(pSMB);
4738 if (rc == -EAGAIN)
4739 goto setPermsRetry;
4740 return rc;
4741 }
4742
4743 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
4744 const int notify_subdirs, const __u16 netfid,
4745 __u32 filter, struct file * pfile, int multishot,
4746 const struct nls_table *nls_codepage)
4747 {
4748 int rc = 0;
4749 struct smb_com_transaction_change_notify_req * pSMB = NULL;
4750 struct smb_com_ntransaction_change_notify_rsp * pSMBr = NULL;
4751 struct dir_notify_req *dnotify_req;
4752 int bytes_returned;
4753
4754 cFYI(1, ("In CIFSSMBNotify for file handle %d",(int)netfid));
4755 rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
4756 (void **) &pSMBr);
4757 if (rc)
4758 return rc;
4759
4760 pSMB->TotalParameterCount = 0 ;
4761 pSMB->TotalDataCount = 0;
4762 pSMB->MaxParameterCount = cpu_to_le32(2);
4763 /* BB find exact data count max from sess structure BB */
4764 pSMB->MaxDataCount = 0; /* same in little endian or be */
4765 /* BB VERIFY verify which is correct for above BB */
4766 pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
4767 MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
4768
4769 pSMB->MaxSetupCount = 4;
4770 pSMB->Reserved = 0;
4771 pSMB->ParameterOffset = 0;
4772 pSMB->DataCount = 0;
4773 pSMB->DataOffset = 0;
4774 pSMB->SetupCount = 4; /* single byte does not need le conversion */
4775 pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
4776 pSMB->ParameterCount = pSMB->TotalParameterCount;
4777 if(notify_subdirs)
4778 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
4779 pSMB->Reserved2 = 0;
4780 pSMB->CompletionFilter = cpu_to_le32(filter);
4781 pSMB->Fid = netfid; /* file handle always le */
4782 pSMB->ByteCount = 0;
4783
4784 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4785 (struct smb_hdr *) pSMBr, &bytes_returned, -1);
4786 if (rc) {
4787 cFYI(1, ("Error in Notify = %d", rc));
4788 } else {
4789 /* Add file to outstanding requests */
4790 /* BB change to kmem cache alloc */
4791 dnotify_req = (struct dir_notify_req *) kmalloc(
4792 sizeof(struct dir_notify_req),
4793 GFP_KERNEL);
4794 if(dnotify_req) {
4795 dnotify_req->Pid = pSMB->hdr.Pid;
4796 dnotify_req->PidHigh = pSMB->hdr.PidHigh;
4797 dnotify_req->Mid = pSMB->hdr.Mid;
4798 dnotify_req->Tid = pSMB->hdr.Tid;
4799 dnotify_req->Uid = pSMB->hdr.Uid;
4800 dnotify_req->netfid = netfid;
4801 dnotify_req->pfile = pfile;
4802 dnotify_req->filter = filter;
4803 dnotify_req->multishot = multishot;
4804 spin_lock(&GlobalMid_Lock);
4805 list_add_tail(&dnotify_req->lhead,
4806 &GlobalDnotifyReqList);
4807 spin_unlock(&GlobalMid_Lock);
4808 } else
4809 rc = -ENOMEM;
4810 }
4811 cifs_buf_release(pSMB);
4812 return rc;
4813 }
4814 #ifdef CONFIG_CIFS_XATTR
4815 ssize_t
4816 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
4817 const unsigned char *searchName,
4818 char * EAData, size_t buf_size,
4819 const struct nls_table *nls_codepage, int remap)
4820 {
4821 /* BB assumes one setup word */
4822 TRANSACTION2_QPI_REQ *pSMB = NULL;
4823 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4824 int rc = 0;
4825 int bytes_returned;
4826 int name_len;
4827 struct fea * temp_fea;
4828 char * temp_ptr;
4829 __u16 params, byte_count;
4830
4831 cFYI(1, ("In Query All EAs path %s", searchName));
4832 QAllEAsRetry:
4833 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4834 (void **) &pSMBr);
4835 if (rc)
4836 return rc;
4837
4838 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4839 name_len =
4840 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
4841 PATH_MAX, nls_codepage, remap);
4842 name_len++; /* trailing null */
4843 name_len *= 2;
4844 } else { /* BB improve the check for buffer overruns BB */
4845 name_len = strnlen(searchName, PATH_MAX);
4846 name_len++; /* trailing null */
4847 strncpy(pSMB->FileName, searchName, name_len);
4848 }
4849
4850 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4851 pSMB->TotalDataCount = 0;
4852 pSMB->MaxParameterCount = cpu_to_le16(2);
4853 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4854 pSMB->MaxSetupCount = 0;
4855 pSMB->Reserved = 0;
4856 pSMB->Flags = 0;
4857 pSMB->Timeout = 0;
4858 pSMB->Reserved2 = 0;
4859 pSMB->ParameterOffset = cpu_to_le16(offsetof(
4860 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
4861 pSMB->DataCount = 0;
4862 pSMB->DataOffset = 0;
4863 pSMB->SetupCount = 1;
4864 pSMB->Reserved3 = 0;
4865 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4866 byte_count = params + 1 /* pad */ ;
4867 pSMB->TotalParameterCount = cpu_to_le16(params);
4868 pSMB->ParameterCount = pSMB->TotalParameterCount;
4869 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
4870 pSMB->Reserved4 = 0;
4871 pSMB->hdr.smb_buf_length += byte_count;
4872 pSMB->ByteCount = cpu_to_le16(byte_count);
4873
4874 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4875 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4876 if (rc) {
4877 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
4878 } else { /* decode response */
4879 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4880
4881 /* BB also check enough total bytes returned */
4882 /* BB we need to improve the validity checking
4883 of these trans2 responses */
4884 if (rc || (pSMBr->ByteCount < 4))
4885 rc = -EIO; /* bad smb */
4886 /* else if (pFindData){
4887 memcpy((char *) pFindData,
4888 (char *) &pSMBr->hdr.Protocol +
4889 data_offset, kl);
4890 }*/ else {
4891 /* check that length of list is not more than bcc */
4892 /* check that each entry does not go beyond length
4893 of list */
4894 /* check that each element of each entry does not
4895 go beyond end of list */
4896 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4897 struct fealist * ea_response_data;
4898 rc = 0;
4899 /* validate_trans2_offsets() */
4900 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
4901 ea_response_data = (struct fealist *)
4902 (((char *) &pSMBr->hdr.Protocol) +
4903 data_offset);
4904 name_len = le32_to_cpu(ea_response_data->list_len);
4905 cFYI(1,("ea length %d", name_len));
4906 if(name_len <= 8) {
4907 /* returned EA size zeroed at top of function */
4908 cFYI(1,("empty EA list returned from server"));
4909 } else {
4910 /* account for ea list len */
4911 name_len -= 4;
4912 temp_fea = ea_response_data->list;
4913 temp_ptr = (char *)temp_fea;
4914 while(name_len > 0) {
4915 __u16 value_len;
4916 name_len -= 4;
4917 temp_ptr += 4;
4918 rc += temp_fea->name_len;
4919 /* account for prefix user. and trailing null */
4920 rc = rc + 5 + 1;
4921 if(rc<(int)buf_size) {
4922 memcpy(EAData,"user.",5);
4923 EAData+=5;
4924 memcpy(EAData,temp_ptr,temp_fea->name_len);
4925 EAData+=temp_fea->name_len;
4926 /* null terminate name */
4927 *EAData = 0;
4928 EAData = EAData + 1;
4929 } else if(buf_size == 0) {
4930 /* skip copy - calc size only */
4931 } else {
4932 /* stop before overrun buffer */
4933 rc = -ERANGE;
4934 break;
4935 }
4936 name_len -= temp_fea->name_len;
4937 temp_ptr += temp_fea->name_len;
4938 /* account for trailing null */
4939 name_len--;
4940 temp_ptr++;
4941 value_len = le16_to_cpu(temp_fea->value_len);
4942 name_len -= value_len;
4943 temp_ptr += value_len;
4944 /* BB check that temp_ptr is still within smb BB*/
4945 /* no trailing null to account for in value len */
4946 /* go on to next EA */
4947 temp_fea = (struct fea *)temp_ptr;
4948 }
4949 }
4950 }
4951 }
4952 if (pSMB)
4953 cifs_buf_release(pSMB);
4954 if (rc == -EAGAIN)
4955 goto QAllEAsRetry;
4956
4957 return (ssize_t)rc;
4958 }
4959
4960 ssize_t CIFSSMBQueryEA(const int xid,struct cifsTconInfo * tcon,
4961 const unsigned char * searchName,const unsigned char * ea_name,
4962 unsigned char * ea_value, size_t buf_size,
4963 const struct nls_table *nls_codepage, int remap)
4964 {
4965 TRANSACTION2_QPI_REQ *pSMB = NULL;
4966 TRANSACTION2_QPI_RSP *pSMBr = NULL;
4967 int rc = 0;
4968 int bytes_returned;
4969 int name_len;
4970 struct fea * temp_fea;
4971 char * temp_ptr;
4972 __u16 params, byte_count;
4973
4974 cFYI(1, ("In Query EA path %s", searchName));
4975 QEARetry:
4976 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4977 (void **) &pSMBr);
4978 if (rc)
4979 return rc;
4980
4981 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4982 name_len =
4983 cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
4984 PATH_MAX, nls_codepage, remap);
4985 name_len++; /* trailing null */
4986 name_len *= 2;
4987 } else { /* BB improve the check for buffer overruns BB */
4988 name_len = strnlen(searchName, PATH_MAX);
4989 name_len++; /* trailing null */
4990 strncpy(pSMB->FileName, searchName, name_len);
4991 }
4992
4993 params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */ ;
4994 pSMB->TotalDataCount = 0;
4995 pSMB->MaxParameterCount = cpu_to_le16(2);
4996 pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
4997 pSMB->MaxSetupCount = 0;
4998 pSMB->Reserved = 0;
4999 pSMB->Flags = 0;
5000 pSMB->Timeout = 0;
5001 pSMB->Reserved2 = 0;
5002 pSMB->ParameterOffset = cpu_to_le16(offsetof(
5003 struct smb_com_transaction2_qpi_req ,InformationLevel) - 4);
5004 pSMB->DataCount = 0;
5005 pSMB->DataOffset = 0;
5006 pSMB->SetupCount = 1;
5007 pSMB->Reserved3 = 0;
5008 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5009 byte_count = params + 1 /* pad */ ;
5010 pSMB->TotalParameterCount = cpu_to_le16(params);
5011 pSMB->ParameterCount = pSMB->TotalParameterCount;
5012 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5013 pSMB->Reserved4 = 0;
5014 pSMB->hdr.smb_buf_length += byte_count;
5015 pSMB->ByteCount = cpu_to_le16(byte_count);
5016
5017 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5018 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5019 if (rc) {
5020 cFYI(1, ("Send error in Query EA = %d", rc));
5021 } else { /* decode response */
5022 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5023
5024 /* BB also check enough total bytes returned */
5025 /* BB we need to improve the validity checking
5026 of these trans2 responses */
5027 if (rc || (pSMBr->ByteCount < 4))
5028 rc = -EIO; /* bad smb */
5029 /* else if (pFindData){
5030 memcpy((char *) pFindData,
5031 (char *) &pSMBr->hdr.Protocol +
5032 data_offset, kl);
5033 }*/ else {
5034 /* check that length of list is not more than bcc */
5035 /* check that each entry does not go beyond length
5036 of list */
5037 /* check that each element of each entry does not
5038 go beyond end of list */
5039 __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5040 struct fealist * ea_response_data;
5041 rc = -ENODATA;
5042 /* validate_trans2_offsets() */
5043 /* BB to check if(start of smb + data_offset > &bcc+ bcc)*/
5044 ea_response_data = (struct fealist *)
5045 (((char *) &pSMBr->hdr.Protocol) +
5046 data_offset);
5047 name_len = le32_to_cpu(ea_response_data->list_len);
5048 cFYI(1,("ea length %d", name_len));
5049 if(name_len <= 8) {
5050 /* returned EA size zeroed at top of function */
5051 cFYI(1,("empty EA list returned from server"));
5052 } else {
5053 /* account for ea list len */
5054 name_len -= 4;
5055 temp_fea = ea_response_data->list;
5056 temp_ptr = (char *)temp_fea;
5057 /* loop through checking if we have a matching
5058 name and then return the associated value */
5059 while(name_len > 0) {
5060 __u16 value_len;
5061 name_len -= 4;
5062 temp_ptr += 4;
5063 value_len = le16_to_cpu(temp_fea->value_len);
5064 /* BB validate that value_len falls within SMB,
5065 even though maximum for name_len is 255 */
5066 if(memcmp(temp_fea->name,ea_name,
5067 temp_fea->name_len) == 0) {
5068 /* found a match */
5069 rc = value_len;
5070 /* account for prefix user. and trailing null */
5071 if(rc<=(int)buf_size) {
5072 memcpy(ea_value,
5073 temp_fea->name+temp_fea->name_len+1,
5074 rc);
5075 /* ea values, unlike ea names,
5076 are not null terminated */
5077 } else if(buf_size == 0) {
5078 /* skip copy - calc size only */
5079 } else {
5080 /* stop before overrun buffer */
5081 rc = -ERANGE;
5082 }
5083 break;
5084 }
5085 name_len -= temp_fea->name_len;
5086 temp_ptr += temp_fea->name_len;
5087 /* account for trailing null */
5088 name_len--;
5089 temp_ptr++;
5090 name_len -= value_len;
5091 temp_ptr += value_len;
5092 /* no trailing null to account for in value len */
5093 /* go on to next EA */
5094 temp_fea = (struct fea *)temp_ptr;
5095 }
5096 }
5097 }
5098 }
5099 if (pSMB)
5100 cifs_buf_release(pSMB);
5101 if (rc == -EAGAIN)
5102 goto QEARetry;
5103
5104 return (ssize_t)rc;
5105 }
5106
5107 int
5108 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
5109 const char * ea_name, const void * ea_value,
5110 const __u16 ea_value_len, const struct nls_table *nls_codepage,
5111 int remap)
5112 {
5113 struct smb_com_transaction2_spi_req *pSMB = NULL;
5114 struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5115 struct fealist *parm_data;
5116 int name_len;
5117 int rc = 0;
5118 int bytes_returned = 0;
5119 __u16 params, param_offset, byte_count, offset, count;
5120
5121 cFYI(1, ("In SetEA"));
5122 SetEARetry:
5123 rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5124 (void **) &pSMBr);
5125 if (rc)
5126 return rc;
5127
5128 if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5129 name_len =
5130 cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5131 PATH_MAX, nls_codepage, remap);
5132 name_len++; /* trailing null */
5133 name_len *= 2;
5134 } else { /* BB improve the check for buffer overruns BB */
5135 name_len = strnlen(fileName, PATH_MAX);
5136 name_len++; /* trailing null */
5137 strncpy(pSMB->FileName, fileName, name_len);
5138 }
5139
5140 params = 6 + name_len;
5141
5142 /* done calculating parms using name_len of file name,
5143 now use name_len to calculate length of ea name
5144 we are going to create in the inode xattrs */
5145 if(ea_name == NULL)
5146 name_len = 0;
5147 else
5148 name_len = strnlen(ea_name,255);
5149
5150 count = sizeof(*parm_data) + ea_value_len + name_len + 1;
5151 pSMB->MaxParameterCount = cpu_to_le16(2);
5152 pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
5153 pSMB->MaxSetupCount = 0;
5154 pSMB->Reserved = 0;
5155 pSMB->Flags = 0;
5156 pSMB->Timeout = 0;
5157 pSMB->Reserved2 = 0;
5158 param_offset = offsetof(struct smb_com_transaction2_spi_req,
5159 InformationLevel) - 4;
5160 offset = param_offset + params;
5161 pSMB->InformationLevel =
5162 cpu_to_le16(SMB_SET_FILE_EA);
5163
5164 parm_data =
5165 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
5166 offset);
5167 pSMB->ParameterOffset = cpu_to_le16(param_offset);
5168 pSMB->DataOffset = cpu_to_le16(offset);
5169 pSMB->SetupCount = 1;
5170 pSMB->Reserved3 = 0;
5171 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5172 byte_count = 3 /* pad */ + params + count;
5173 pSMB->DataCount = cpu_to_le16(count);
5174 parm_data->list_len = cpu_to_le32(count);
5175 parm_data->list[0].EA_flags = 0;
5176 /* we checked above that name len is less than 255 */
5177 parm_data->list[0].name_len = (__u8)name_len;
5178 /* EA names are always ASCII */
5179 if(ea_name)
5180 strncpy(parm_data->list[0].name,ea_name,name_len);
5181 parm_data->list[0].name[name_len] = 0;
5182 parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
5183 /* caller ensures that ea_value_len is less than 64K but
5184 we need to ensure that it fits within the smb */
5185
5186 /*BB add length check that it would fit in negotiated SMB buffer size BB */
5187 /* if(ea_value_len > buffer_size - 512 (enough for header)) */
5188 if(ea_value_len)
5189 memcpy(parm_data->list[0].name+name_len+1,ea_value,ea_value_len);
5190
5191 pSMB->TotalDataCount = pSMB->DataCount;
5192 pSMB->ParameterCount = cpu_to_le16(params);
5193 pSMB->TotalParameterCount = pSMB->ParameterCount;
5194 pSMB->Reserved4 = 0;
5195 pSMB->hdr.smb_buf_length += byte_count;
5196 pSMB->ByteCount = cpu_to_le16(byte_count);
5197 rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5198 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5199 if (rc) {
5200 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
5201 }
5202
5203 cifs_buf_release(pSMB);
5204
5205 if (rc == -EAGAIN)
5206 goto SetEARetry;
5207
5208 return rc;
5209 }
5210
5211 #endif
Verdex Pro support