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