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