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