projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
CIFS: Simplify connection structure search calls
[deliverable/linux.git] / fs / cifs / connect.c
CommitLineData
1da177e4
LT		 1/*
2 * fs/cifs/connect.c
3 *
d185cda7 4 * Copyright (C) International Business Machines Corp., 2002,2009
1da177e4
LT		 5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
fb8c4b14 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1da177e4
LT		 20 */
21#include <linux/fs.h>
22#include <linux/net.h>
23#include <linux/string.h>
24#include <linux/list.h>
25#include <linux/wait.h>
5a0e3ad6 26#include <linux/slab.h>
1da177e4
LT		 27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
b8643e1b 31#include <linux/delay.h>
f191401f 32#include <linux/completion.h>
aaf737ad 33#include <linux/kthread.h>
0ae0efad 34#include <linux/pagevec.h>
7dfb7103 35#include <linux/freezer.h>
5c2503a8 36#include <linux/namei.h>
1da177e4
LT		 37#include <asm/uaccess.h>
38#include <asm/processor.h>
50b64e3b 39#include <linux/inet.h>
0e2bedaa 40#include <net/ipv6.h>
1da177e4
LT		 41#include "cifspdu.h"
42#include "cifsglob.h"
43#include "cifsproto.h"
44#include "cifs_unicode.h"
45#include "cifs_debug.h"
46#include "cifs_fs_sb.h"
47#include "ntlmssp.h"
48#include "nterr.h"
49#include "rfc1002pdu.h"
488f1d2d 50#include "fscache.h"
1da177e4
LT		 51
52#define CIFS_PORT 445
53#define RFC1001_PORT 139
54
c74093b6
JL		 55/* SMB echo "timeout" -- FIXME: tunable? */
56#define SMB_ECHO_INTERVAL (60 * HZ)
57
1da177e4
LT		 58extern mempool_t *cifs_req_poolp;
59
60struct smb_vol {
61 char *username;
62 char *password;
63 char *domainname;
64 char *UNC;
65 char *UNCip;
1da177e4 66 char *iocharset; /* local code page for mapping to and from Unicode */
1397f2ee
JL		 67 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
68 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
3e4b3e1f 69 uid_t cred_uid;
1da177e4
LT		 70 uid_t linux_uid;
71 gid_t linux_gid;
72 mode_t file_mode;
73 mode_t dir_mode;
189acaae 74 unsigned secFlg;
4b18f2a9
SF		 75 bool retry:1;
76 bool intr:1;
77 bool setuids:1;
78 bool override_uid:1;
79 bool override_gid:1;
d0a9c078 80 bool dynperm:1;
4b18f2a9
SF		 81 bool noperm:1;
82 bool no_psx_acl:1; /* set if posix acl support should be disabled */
83 bool cifs_acl:1;
84 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
85 bool server_ino:1; /* use inode numbers from server ie UniqueId */
86 bool direct_io:1;
d39454ff 87 bool strict_io:1; /* strict cache behavior */
95b1cb90
SF		 88 bool remap:1; /* set to remap seven reserved chars in filenames */
89 bool posix_paths:1; /* unset to not ask for posix pathnames. */
4b18f2a9
SF		 90 bool no_linux_ext:1;
91 bool sfu_emul:1;
95b1cb90
SF		 92 bool nullauth:1; /* attempt to authenticate with null user */
93 bool nocase:1; /* request case insensitive filenames */
94 bool nobrl:1; /* disable sending byte range locks to srv */
13a6e42a 95 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
95b1cb90 96 bool seal:1; /* request transport encryption on share */
84210e91
SF		 97 bool nodfs:1; /* Do not request DFS, even if available */
98 bool local_lease:1; /* check leases only on local system, not remote */
edf1ae40
SF		 99 bool noblocksnd:1;
100 bool noautotune:1;
be652445 101 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
fa1df75d 102 bool fsc:1; /* enable fscache */
736a3320 103 bool mfsymlinks:1; /* use Minshall+French Symlinks */
0eb8a132 104 bool multiuser:1;
1da177e4
LT		 105 unsigned int rsize;
106 unsigned int wsize;
6a5fa236 107 bool sockopt_tcp_nodelay:1;
1da177e4 108 unsigned short int port;
6d20e840 109 unsigned long actimeo; /* attribute cache timeout (jiffies) */
fb8c4b14 110 char *prepath;
3eb9a889 111 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
a5fc4ce0 112 struct nls_table *local_nls;
1da177e4
LT		 113};
114
2de970ff 115/* FIXME: should these be tunable? */
9d002df4 116#define TLINK_ERROR_EXPIRE (1 * HZ)
2de970ff 117#define TLINK_IDLE_EXPIRE (600 * HZ)
9d002df4 118
a9f1b85e
PS		 119static int ip_connect(struct TCP_Server_Info *server);
120static int generic_ip_connect(struct TCP_Server_Info *server);
b647c35f 121static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
2de970ff 122static void cifs_prune_tlinks(struct work_struct *work);
1da177e4 123
d5c5605c
JL		 124/*
125 * cifs tcp session reconnection
126 *
127 * mark tcp session as reconnecting so temporarily locked
128 * mark all smb sessions as reconnecting for tcp session
129 * reconnect tcp session
130 * wake up waiters on reconnection? - (not needed currently)
131 */
2cd646a2 132static int
1da177e4
LT		 133cifs_reconnect(struct TCP_Server_Info *server)
134{
135 int rc = 0;
f1987b44 136 struct list_head *tmp, *tmp2;
1da177e4
LT		 137 struct cifsSesInfo *ses;
138 struct cifsTconInfo *tcon;
fb8c4b14 139 struct mid_q_entry *mid_entry;
50c2f753 140
1da177e4 141 spin_lock(&GlobalMid_Lock);
469ee614 142 if (server->tcpStatus == CifsExiting) {
fb8c4b14 143 /* the demux thread will exit normally
1da177e4
LT		 144 next time through the loop */
145 spin_unlock(&GlobalMid_Lock);
146 return rc;
147 } else
148 server->tcpStatus = CifsNeedReconnect;
149 spin_unlock(&GlobalMid_Lock);
150 server->maxBuf = 0;
151
b6b38f70 152 cFYI(1, "Reconnecting tcp session");
1da177e4
LT		 153
154 /* before reconnecting the tcp session, mark the smb session (uid)
155 and the tid bad so they are not used until reconnected */
2b84a36c 156 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
3f9bcca7 157 spin_lock(&cifs_tcp_ses_lock);
14fbf50d
JL		 158 list_for_each(tmp, &server->smb_ses_list) {
159 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
160 ses->need_reconnect = true;
161 ses->ipc_tid = 0;
f1987b44
JL		 162 list_for_each(tmp2, &ses->tcon_list) {
163 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
3b795210 164 tcon->need_reconnect = true;
1da177e4 165 }
1da177e4 166 }
3f9bcca7 167 spin_unlock(&cifs_tcp_ses_lock);
2b84a36c 168
1da177e4 169 /* do not want to be sending data on a socket we are freeing */
2b84a36c 170 cFYI(1, "%s: tearing down socket", __func__);
72ca545b 171 mutex_lock(&server->srv_mutex);
fb8c4b14 172 if (server->ssocket) {
b6b38f70
JP		 173 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
174 server->ssocket->flags);
91cf45f0 175 kernel_sock_shutdown(server->ssocket, SHUT_WR);
b6b38f70 176 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
467a8f8d 177 server->ssocket->state,
b6b38f70 178 server->ssocket->flags);
1da177e4
LT		 179 sock_release(server->ssocket);
180 server->ssocket = NULL;
181 }
5d0d2882
SP		 182 server->sequence_number = 0;
183 server->session_estab = false;
21e73393
SP		 184 kfree(server->session_key.response);
185 server->session_key.response = NULL;
186 server->session_key.len = 0;
fda35943 187 server->lstrp = jiffies;
2b84a36c 188 mutex_unlock(&server->srv_mutex);
1da177e4 189
2b84a36c
JL		 190 /* mark submitted MIDs for retry and issue callback */
191 cFYI(1, "%s: issuing mid callbacks", __func__);
1da177e4 192 spin_lock(&GlobalMid_Lock);
2b84a36c
JL		 193 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
194 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
195 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
ad8b15f0 196 mid_entry->midState = MID_RETRY_NEEDED;
2b84a36c
JL		 197 list_del_init(&mid_entry->qhead);
198 mid_entry->callback(mid_entry);
1da177e4
LT		 199 }
200 spin_unlock(&GlobalMid_Lock);
1da177e4 201
fd88ce93 202 while (server->tcpStatus == CifsNeedReconnect) {
6c3d8909 203 try_to_freeze();
a9f1b85e
PS		 204
205 /* we should try only the port we connected to before */
206 rc = generic_ip_connect(server);
fb8c4b14 207 if (rc) {
b6b38f70 208 cFYI(1, "reconnect error %d", rc);
0cb766ae 209 msleep(3000);
1da177e4
LT		 210 } else {
211 atomic_inc(&tcpSesReconnectCount);
212 spin_lock(&GlobalMid_Lock);
469ee614 213 if (server->tcpStatus != CifsExiting)
fd88ce93 214 server->tcpStatus = CifsNeedNegotiate;
fb8c4b14 215 spin_unlock(&GlobalMid_Lock);
1da177e4
LT		 216 }
217 }
2b84a36c 218
1da177e4
LT		 219 return rc;
220}
221
fb8c4b14 222/*
e4eb295d
SF		 223 return codes:
224 0 not a transact2, or all data present
225 >0 transact2 with that much data missing
226 -EINVAL = invalid transact2
227
228 */
fb8c4b14 229static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
e4eb295d 230{
fb8c4b14 231 struct smb_t2_rsp *pSMBt;
e4eb295d 232 int remaining;
26ec2548 233 __u16 total_data_size, data_in_this_rsp;
e4eb295d 234
fb8c4b14 235 if (pSMB->Command != SMB_COM_TRANSACTION2)
e4eb295d
SF		 236 return 0;
237
fb8c4b14
SF		 238 /* check for plausible wct, bcc and t2 data and parm sizes */
239 /* check for parm and data offset going beyond end of smb */
240 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
b6b38f70 241 cFYI(1, "invalid transact2 word count");
e4eb295d
SF		 242 return -EINVAL;
243 }
244
245 pSMBt = (struct smb_t2_rsp *)pSMB;
246
26ec2548
JL		 247 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
248 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
e4eb295d 249
c0c7b905 250 if (total_data_size == data_in_this_rsp)
e4eb295d 251 return 0;
c0c7b905 252 else if (total_data_size < data_in_this_rsp) {
b6b38f70
JP		 253 cFYI(1, "total data %d smaller than data in frame %d",
254 total_data_size, data_in_this_rsp);
e4eb295d 255 return -EINVAL;
e4eb295d 256 }
c0c7b905
JL		 257
258 remaining = total_data_size - data_in_this_rsp;
259
260 cFYI(1, "missing %d bytes from transact2, check next response",
261 remaining);
262 if (total_data_size > maxBufSize) {
263 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
264 total_data_size, maxBufSize);
265 return -EINVAL;
266 }
267 return remaining;
e4eb295d
SF		 268}
269
fb8c4b14 270static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
e4eb295d
SF		 271{
272 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
273 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
fb8c4b14
SF		 274 char *data_area_of_target;
275 char *data_area_of_buf2;
26ec2548 276 int remaining;
2a2047bc
JL		 277 unsigned int byte_count, total_in_buf;
278 __u16 total_data_size, total_in_buf2;
e4eb295d 279
26ec2548 280 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
e4eb295d 281
26ec2548
JL		 282 if (total_data_size !=
283 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
b6b38f70 284 cFYI(1, "total data size of primary and secondary t2 differ");
e4eb295d 285
26ec2548 286 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
e4eb295d
SF		 287
288 remaining = total_data_size - total_in_buf;
50c2f753 289
fb8c4b14 290 if (remaining < 0)
2a2047bc 291 return -EPROTO;
e4eb295d 292
fb8c4b14 293 if (remaining == 0) /* nothing to do, ignore */
e4eb295d 294 return 0;
50c2f753 295
26ec2548 296 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
fb8c4b14 297 if (remaining < total_in_buf2) {
b6b38f70 298 cFYI(1, "transact2 2nd response contains too much data");
e4eb295d
SF		 299 }
300
301 /* find end of first SMB data area */
fb8c4b14 302 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
26ec2548 303 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
e4eb295d
SF		 304 /* validate target area */
305
26ec2548
JL		 306 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
307 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
e4eb295d
SF		 308
309 data_area_of_target += total_in_buf;
310
311 /* copy second buffer into end of first buffer */
e4eb295d 312 total_in_buf += total_in_buf2;
2a2047bc
JL		 313 /* is the result too big for the field? */
314 if (total_in_buf > USHRT_MAX)
315 return -EPROTO;
26ec2548 316 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
2a2047bc
JL		 317
318 /* fix up the BCC */
820a803f 319 byte_count = get_bcc(pTargetSMB);
e4eb295d 320 byte_count += total_in_buf2;
2a2047bc
JL		 321 /* is the result too big for the field? */
322 if (byte_count > USHRT_MAX)
323 return -EPROTO;
820a803f 324 put_bcc(byte_count, pTargetSMB);
e4eb295d 325
be8e3b00 326 byte_count = be32_to_cpu(pTargetSMB->smb_buf_length);
e4eb295d 327 byte_count += total_in_buf2;
2a2047bc
JL		 328 /* don't allow buffer to overflow */
329 if (byte_count > CIFSMaxBufSize)
330 return -ENOBUFS;
be8e3b00 331 pTargetSMB->smb_buf_length = cpu_to_be32(byte_count);
e4eb295d 332
2a2047bc
JL		 333 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
334
fb8c4b14 335 if (remaining == total_in_buf2) {
b6b38f70 336 cFYI(1, "found the last secondary response");
e4eb295d
SF		 337 return 0; /* we are done */
338 } else /* more responses to go */
339 return 1;
e4eb295d
SF		 340}
341
c74093b6
JL		 342static void
343cifs_echo_request(struct work_struct *work)
344{
345 int rc;
346 struct TCP_Server_Info *server = container_of(work,
347 struct TCP_Server_Info, echo.work);
348
247ec9b4 349 /*
195291e6
JL		 350 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
351 * done, which is indicated by maxBuf != 0. Also, no need to ping if
352 * we got a response recently
247ec9b4 353 */
195291e6 354 if (server->maxBuf == 0 ||
247ec9b4 355 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
c74093b6
JL		 356 goto requeue_echo;
357
358 rc = CIFSSMBEcho(server);
359 if (rc)
360 cFYI(1, "Unable to send echo request to server: %s",
361 server->hostname);
362
363requeue_echo:
364 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
365}
366
1da177e4
LT		 367static int
368cifs_demultiplex_thread(struct TCP_Server_Info *server)
369{
370 int length;
371 unsigned int pdu_length, total_read;
372 struct smb_hdr *smb_buffer = NULL;
b8643e1b
SF		 373 struct smb_hdr *bigbuf = NULL;
374 struct smb_hdr *smallbuf = NULL;
1da177e4
LT		 375 struct msghdr smb_msg;
376 struct kvec iov;
377 struct socket *csocket = server->ssocket;
2b84a36c 378 struct list_head *tmp, *tmp2;
1da177e4
LT		 379 struct task_struct *task_to_wake = NULL;
380 struct mid_q_entry *mid_entry;
70ca734a 381 char temp;
4b18f2a9
SF		 382 bool isLargeBuf = false;
383 bool isMultiRsp;
e4eb295d 384 int reconnect;
1da177e4 385
1da177e4 386 current->flags |= PF_MEMALLOC;
b6b38f70 387 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
93d0ec85
JL		 388
389 length = atomic_inc_return(&tcpSesAllocCount);
390 if (length > 1)
26f57364
SF		 391 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
392 GFP_KERNEL);
1da177e4 393
83144186 394 set_freezable();
469ee614 395 while (server->tcpStatus != CifsExiting) {
ede1327e
SF		 396 if (try_to_freeze())
397 continue;
b8643e1b
SF		 398 if (bigbuf == NULL) {
399 bigbuf = cifs_buf_get();
0fd1ffe0 400 if (!bigbuf) {
b6b38f70 401 cERROR(1, "No memory for large SMB response");
b8643e1b
SF		 402 msleep(3000);
403 /* retry will check if exiting */
404 continue;
405 }
0fd1ffe0
PM		 406 } else if (isLargeBuf) {
407 /* we are reusing a dirty large buf, clear its start */
26f57364 408 memset(bigbuf, 0, sizeof(struct smb_hdr));
1da177e4 409 }
b8643e1b
SF		 410
411 if (smallbuf == NULL) {
412 smallbuf = cifs_small_buf_get();
0fd1ffe0 413 if (!smallbuf) {
b6b38f70 414 cERROR(1, "No memory for SMB response");
b8643e1b
SF		 415 msleep(1000);
416 /* retry will check if exiting */
417 continue;
418 }
419 /* beginning of smb buffer is cleared in our buf_get */
420 } else /* if existing small buf clear beginning */
26f57364 421 memset(smallbuf, 0, sizeof(struct smb_hdr));
b8643e1b 422
4b18f2a9
SF		 423 isLargeBuf = false;
424 isMultiRsp = false;
b8643e1b 425 smb_buffer = smallbuf;
1da177e4
LT		 426 iov.iov_base = smb_buffer;
427 iov.iov_len = 4;
428 smb_msg.msg_control = NULL;
429 smb_msg.msg_controllen = 0;
f01d5e14 430 pdu_length = 4; /* enough to get RFC1001 header */
fda35943 431
f01d5e14 432incomplete_rcv:
fd88ce93 433 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
fda35943
SF		 434 time_after(jiffies, server->lstrp +
435 (echo_retries * SMB_ECHO_INTERVAL))) {
436 cERROR(1, "Server %s has not responded in %d seconds. "
437 "Reconnecting...", server->hostname,
438 (echo_retries * SMB_ECHO_INTERVAL / HZ));
439 cifs_reconnect(server);
440 csocket = server->ssocket;
441 wake_up(&server->response_q);
442 continue;
443 }
444
1da177e4
LT		 445 length =
446 kernel_recvmsg(csocket, &smb_msg,
f01d5e14 447 &iov, 1, pdu_length, 0 /* BB other flags? */);
1da177e4 448
469ee614 449 if (server->tcpStatus == CifsExiting) {
1da177e4
LT		 450 break;
451 } else if (server->tcpStatus == CifsNeedReconnect) {
b6b38f70 452 cFYI(1, "Reconnect after server stopped responding");
1da177e4 453 cifs_reconnect(server);
b6b38f70 454 cFYI(1, "call to reconnect done");
1da177e4
LT		 455 csocket = server->ssocket;
456 continue;
522bbe65
JL		 457 } else if (length == -ERESTARTSYS ||
458 length == -EAGAIN ||
459 length == -EINTR) {
b8643e1b 460 msleep(1); /* minimum sleep to prevent looping
1da177e4
LT		 461 allowing socket to clear and app threads to set
462 tcpStatus CifsNeedReconnect if server hung */
c527c8a7
SF		 463 if (pdu_length < 4) {
464 iov.iov_base = (4 - pdu_length) +
465 (char *)smb_buffer;
466 iov.iov_len = pdu_length;
467 smb_msg.msg_control = NULL;
468 smb_msg.msg_controllen = 0;
c18c732e 469 goto incomplete_rcv;
c527c8a7 470 } else
c18c732e 471 continue;
1da177e4 472 } else if (length <= 0) {
b6b38f70
JP		 473 cFYI(1, "Reconnect after unexpected peek error %d",
474 length);
1da177e4
LT		 475 cifs_reconnect(server);
476 csocket = server->ssocket;
477 wake_up(&server->response_q);
478 continue;
2a974680 479 } else if (length < pdu_length) {
b6b38f70
JP		 480 cFYI(1, "requested %d bytes but only got %d bytes",
481 pdu_length, length);
f01d5e14 482 pdu_length -= length;
f01d5e14
SF		 483 msleep(1);
484 goto incomplete_rcv;
46810cbf 485 }
1da177e4 486
70ca734a
SF		 487 /* The right amount was read from socket - 4 bytes */
488 /* so we can now interpret the length field */
46810cbf 489
70ca734a
SF		 490 /* the first byte big endian of the length field,
491 is actually not part of the length but the type
492 with the most common, zero, as regular data */
493 temp = *((char *) smb_buffer);
46810cbf 494
fb8c4b14 495 /* Note that FC 1001 length is big endian on the wire,
70ca734a
SF		 496 but we convert it here so it is always manipulated
497 as host byte order */
be8e3b00 498 pdu_length = be32_to_cpu(smb_buffer->smb_buf_length);
70ca734a 499
b6b38f70 500 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
46810cbf 501
70ca734a 502 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
fb8c4b14 503 continue;
70ca734a 504 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
b6b38f70 505 cFYI(1, "Good RFC 1002 session rsp");
e4eb295d 506 continue;
70ca734a 507 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
fb8c4b14 508 /* we get this from Windows 98 instead of
46810cbf 509 an error on SMB negprot response */
b6b38f70
JP		 510 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
511 pdu_length);
7332f2a6
JL		 512 /* give server a second to clean up */
513 msleep(1000);
514 /* always try 445 first on reconnect since we get NACK
515 * on some if we ever connected to port 139 (the NACK
516 * is since we do not begin with RFC1001 session
517 * initialize frame)
518 */
32670396 519 cifs_set_port((struct sockaddr *)
a9f1b85e 520 &server->dstaddr, CIFS_PORT);
7332f2a6
JL		 521 cifs_reconnect(server);
522 csocket = server->ssocket;
523 wake_up(&server->response_q);
524 continue;
70ca734a 525 } else if (temp != (char) 0) {
b6b38f70 526 cERROR(1, "Unknown RFC 1002 frame");
70ca734a
SF		 527 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
528 length);
46810cbf
SF		 529 cifs_reconnect(server);
530 csocket = server->ssocket;
531 continue;
e4eb295d
SF		 532 }
533
534 /* else we have an SMB response */
fb8c4b14 535 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
26f57364 536 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
b6b38f70
JP		 537 cERROR(1, "Invalid size SMB length %d pdu_length %d",
538 length, pdu_length+4);
e4eb295d
SF		 539 cifs_reconnect(server);
540 csocket = server->ssocket;
541 wake_up(&server->response_q);
542 continue;
fb8c4b14 543 }
e4eb295d
SF		 544
545 /* else length ok */
546 reconnect = 0;
547
fb8c4b14 548 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
4b18f2a9 549 isLargeBuf = true;
e4eb295d
SF		 550 memcpy(bigbuf, smallbuf, 4);
551 smb_buffer = bigbuf;
552 }
553 length = 0;
554 iov.iov_base = 4 + (char *)smb_buffer;
555 iov.iov_len = pdu_length;
fb8c4b14 556 for (total_read = 0; total_read < pdu_length;
e4eb295d
SF		 557 total_read += length) {
558 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
559 pdu_length - total_read, 0);
522bbe65 560 if (server->tcpStatus == CifsExiting) {
e4eb295d
SF		 561 /* then will exit */
562 reconnect = 2;
563 break;
564 } else if (server->tcpStatus == CifsNeedReconnect) {
46810cbf
SF		 565 cifs_reconnect(server);
566 csocket = server->ssocket;
fb8c4b14 567 /* Reconnect wakes up rspns q */
e4eb295d
SF		 568 /* Now we will reread sock */
569 reconnect = 1;
570 break;
522bbe65
JL		 571 } else if (length == -ERESTARTSYS ||
572 length == -EAGAIN ||
573 length == -EINTR) {
e4eb295d 574 msleep(1); /* minimum sleep to prevent looping,
fb8c4b14 575 allowing socket to clear and app
e4eb295d
SF		 576 threads to set tcpStatus
577 CifsNeedReconnect if server hung*/
c18c732e 578 length = 0;
46810cbf 579 continue;
e4eb295d 580 } else if (length <= 0) {
b6b38f70
JP		 581 cERROR(1, "Received no data, expecting %d",
582 pdu_length - total_read);
e4eb295d
SF		 583 cifs_reconnect(server);
584 csocket = server->ssocket;
585 reconnect = 1;
586 break;
46810cbf 587 }
e4eb295d 588 }
fb8c4b14 589 if (reconnect == 2)
e4eb295d 590 break;
fb8c4b14 591 else if (reconnect == 1)
e4eb295d 592 continue;
1da177e4 593
9587fcff 594 total_read += 4; /* account for rfc1002 hdr */
50c2f753 595
9587fcff 596 dump_smb(smb_buffer, total_read);
71823baf
JL		 597
598 /*
599 * We know that we received enough to get to the MID as we
600 * checked the pdu_length earlier. Now check to see
601 * if the rest of the header is OK. We borrow the length
602 * var for the rest of the loop to avoid a new stack var.
603 *
604 * 48 bytes is enough to display the header and a little bit
605 * into the payload for debugging purposes.
606 */
607 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
608 if (length != 0)
9587fcff 609 cifs_dump_mem("Bad SMB: ", smb_buffer,
71823baf 610 min_t(unsigned int, total_read, 48));
1da177e4 611
2b84a36c 612 mid_entry = NULL;
fda35943
SF		 613 server->lstrp = jiffies;
614
e4eb295d 615 spin_lock(&GlobalMid_Lock);
2b84a36c 616 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
e4eb295d
SF		 617 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
618
146f9f65
JL		 619 if (mid_entry->mid != smb_buffer->Mid ||
620 mid_entry->midState != MID_REQUEST_SUBMITTED ||
621 mid_entry->command != smb_buffer->Command) {
622 mid_entry = NULL;
623 continue;
624 }
625
626 if (length == 0 &&
627 check2ndT2(smb_buffer, server->maxBuf) > 0) {
628 /* We have a multipart transact2 resp */
629 isMultiRsp = true;
630 if (mid_entry->resp_buf) {
631 /* merge response - fix up 1st*/
16541ba1
JL		 632 length = coalesce_t2(smb_buffer,
633 mid_entry->resp_buf);
634 if (length > 0) {
635 length = 0;
146f9f65
JL		 636 mid_entry->multiRsp = true;
637 break;
e4eb295d 638 } else {
16541ba1
JL		 639 /* all parts received or
640 * packet is malformed
641 */
146f9f65
JL		 642 mid_entry->multiEnd = true;
643 goto multi_t2_fnd;
644 }
645 } else {
646 if (!isLargeBuf) {
647 /*
648 * FIXME: switch to already
649 * allocated largebuf?
650 */
651 cERROR(1, "1st trans2 resp "
652 "needs bigbuf");
653 } else {
654 /* Have first buffer */
655 mid_entry->resp_buf =
656 smb_buffer;
657 mid_entry->largeBuf = true;
658 bigbuf = NULL;
e4eb295d 659 }
50c2f753 660 }
146f9f65
JL		 661 break;
662 }
663 mid_entry->resp_buf = smb_buffer;
664 mid_entry->largeBuf = isLargeBuf;
e4eb295d 665multi_t2_fnd:
146f9f65
JL		 666 if (length == 0)
667 mid_entry->midState = MID_RESPONSE_RECEIVED;
668 else
669 mid_entry->midState = MID_RESPONSE_MALFORMED;
1047abc1 670#ifdef CONFIG_CIFS_STATS2
146f9f65 671 mid_entry->when_received = jiffies;
1047abc1 672#endif
146f9f65
JL		 673 list_del_init(&mid_entry->qhead);
674 mid_entry->callback(mid_entry);
675 break;
1da177e4 676 }
e4eb295d 677 spin_unlock(&GlobalMid_Lock);
2b84a36c
JL		 678
679 if (mid_entry != NULL) {
cd63499c 680 /* Was previous buf put in mpx struct for multi-rsp? */
fb8c4b14 681 if (!isMultiRsp) {
cd63499c 682 /* smb buffer will be freed by user thread */
26f57364 683 if (isLargeBuf)
cd63499c 684 bigbuf = NULL;
26f57364 685 else
cd63499c
SF		 686 smallbuf = NULL;
687 }
71823baf
JL		 688 } else if (length != 0) {
689 /* response sanity checks failed */
690 continue;
4b18f2a9
SF		 691 } else if (!is_valid_oplock_break(smb_buffer, server) &&
692 !isMultiRsp) {
b6b38f70 693 cERROR(1, "No task to wake, unknown frame received! "
8097531a 694 "NumMids %d", atomic_read(&midCount));
50c2f753 695 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
70ca734a 696 sizeof(struct smb_hdr));
3979877e
SF		 697#ifdef CONFIG_CIFS_DEBUG2
698 cifs_dump_detail(smb_buffer);
699 cifs_dump_mids(server);
700#endif /* CIFS_DEBUG2 */
50c2f753 701
e4eb295d
SF		 702 }
703 } /* end while !EXITING */
704
e7ddee90 705 /* take it off the list, if it's not already */
3f9bcca7 706 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 707 list_del_init(&server->tcp_ses_list);
3f9bcca7 708 spin_unlock(&cifs_tcp_ses_lock);
e7ddee90 709
1da177e4
LT		 710 spin_lock(&GlobalMid_Lock);
711 server->tcpStatus = CifsExiting;
e691b9d1 712 spin_unlock(&GlobalMid_Lock);
dbdbb876 713 wake_up_all(&server->response_q);
e691b9d1 714
31ca3bc3
SF		 715 /* check if we have blocked requests that need to free */
716 /* Note that cifs_max_pending is normally 50, but
717 can be set at module install time to as little as two */
e691b9d1 718 spin_lock(&GlobalMid_Lock);
fb8c4b14 719 if (atomic_read(&server->inFlight) >= cifs_max_pending)
31ca3bc3
SF		 720 atomic_set(&server->inFlight, cifs_max_pending - 1);
721 /* We do not want to set the max_pending too low or we
722 could end up with the counter going negative */
1da177e4 723 spin_unlock(&GlobalMid_Lock);
50c2f753 724 /* Although there should not be any requests blocked on
1da177e4 725 this queue it can not hurt to be paranoid and try to wake up requests
09d1db5c 726 that may haven been blocked when more than 50 at time were on the wire
1da177e4
LT		 727 to the same server - they now will see the session is in exit state
728 and get out of SendReceive. */
729 wake_up_all(&server->request_q);
730 /* give those requests time to exit */
b8643e1b 731 msleep(125);
50c2f753 732
fb8c4b14 733 if (server->ssocket) {
1da177e4
LT		 734 sock_release(csocket);
735 server->ssocket = NULL;
736 }
fd62cb7e 737 /* buffer usually freed in free_mid - need to free it here on exit */
a8a11d39
MK		 738 cifs_buf_release(bigbuf);
739 if (smallbuf) /* no sense logging a debug message if NULL */
b8643e1b 740 cifs_small_buf_release(smallbuf);
1da177e4 741
9d78315b 742 if (!list_empty(&server->pending_mid_q)) {
1da177e4 743 spin_lock(&GlobalMid_Lock);
2b84a36c 744 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
9d78315b 745 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
2b84a36c
JL		 746 cFYI(1, "Clearing Mid 0x%x - issuing callback",
747 mid_entry->mid);
748 list_del_init(&mid_entry->qhead);
749 mid_entry->callback(mid_entry);
1da177e4
LT		 750 }
751 spin_unlock(&GlobalMid_Lock);
1da177e4 752 /* 1/8th of sec is more than enough time for them to exit */
b8643e1b 753 msleep(125);
1da177e4
LT		 754 }
755
f191401f 756 if (!list_empty(&server->pending_mid_q)) {
50c2f753 757 /* mpx threads have not exited yet give them
1da177e4 758 at least the smb send timeout time for long ops */
31ca3bc3
SF		 759 /* due to delays on oplock break requests, we need
760 to wait at least 45 seconds before giving up
761 on a request getting a response and going ahead
762 and killing cifsd */
b6b38f70 763 cFYI(1, "Wait for exit from demultiplex thread");
31ca3bc3 764 msleep(46000);
1da177e4
LT		 765 /* if threads still have not exited they are probably never
766 coming home not much else we can do but free the memory */
767 }
1da177e4 768
c359cf3c 769 kfree(server->hostname);
b1c8d2b4 770 task_to_wake = xchg(&server->tsk, NULL);
31ca3bc3 771 kfree(server);
93d0ec85
JL		 772
773 length = atomic_dec_return(&tcpSesAllocCount);
26f57364
SF		 774 if (length > 0)
775 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
776 GFP_KERNEL);
50c2f753 777
b1c8d2b4
JL		 778 /* if server->tsk was NULL then wait for a signal before exiting */
779 if (!task_to_wake) {
780 set_current_state(TASK_INTERRUPTIBLE);
781 while (!signal_pending(current)) {
782 schedule();
783 set_current_state(TASK_INTERRUPTIBLE);
784 }
785 set_current_state(TASK_RUNNING);
786 }
787
0468a2cf 788 module_put_and_exit(0);
1da177e4
LT		 789}
790
c359cf3c
JL		 791/* extract the host portion of the UNC string */
792static char *
793extract_hostname(const char *unc)
794{
795 const char *src;
796 char *dst, *delim;
797 unsigned int len;
798
799 /* skip double chars at beginning of string */
800 /* BB: check validity of these bytes? */
801 src = unc + 2;
802
803 /* delimiter between hostname and sharename is always '\\' now */
804 delim = strchr(src, '\\');
805 if (!delim)
806 return ERR_PTR(-EINVAL);
807
808 len = delim - src;
809 dst = kmalloc((len + 1), GFP_KERNEL);
810 if (dst == NULL)
811 return ERR_PTR(-ENOMEM);
812
813 memcpy(dst, src, len);
814 dst[len] = '\0';
815
816 return dst;
817}
818
1da177e4 819static int
b946845a 820cifs_parse_mount_options(const char *mountdata, const char *devname,
50c2f753 821 struct smb_vol *vol)
1da177e4 822{
4906e50b 823 char *value, *data, *end;
b946845a 824 char *mountdata_copy, *options;
1da177e4
LT		 825 unsigned int temp_len, i, j;
826 char separator[2];
9b9d6b24
JL		 827 short int override_uid = -1;
828 short int override_gid = -1;
829 bool uid_specified = false;
830 bool gid_specified = false;
88463999 831 char *nodename = utsname()->nodename;
1da177e4
LT		 832
833 separator[0] = ',';
50c2f753 834 separator[1] = 0;
1da177e4 835
88463999
JL		 836 /*
837 * does not have to be perfect mapping since field is
838 * informational, only used for servers that do not support
839 * port 445 and it can be overridden at mount time
840 */
1397f2ee
JL		 841 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
842 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
88463999
JL		 843 vol->source_rfc1001_name[i] = toupper(nodename[i]);
844
1397f2ee 845 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
a10faeb2
SF		 846 /* null target name indicates to use *SMBSERVR default called name
847 if we end up sending RFC1001 session initialize */
848 vol->target_rfc1001_name[0] = 0;
3e4b3e1f
JL		 849 vol->cred_uid = current_uid();
850 vol->linux_uid = current_uid();
a001e5b5 851 vol->linux_gid = current_gid();
f55ed1a8
JL		 852
853 /* default to only allowing write access to owner of the mount */
854 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1da177e4
LT		 855
856 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
ac67055e
JA		 857 /* default is always to request posix paths. */
858 vol->posix_paths = 1;
a0c9217f
JL		 859 /* default to using server inode numbers where available */
860 vol->server_ino = 1;
ac67055e 861
6d20e840
SJ		 862 vol->actimeo = CIFS_DEF_ACTIMEO;
863
b946845a
SF		 864 if (!mountdata)
865 goto cifs_parse_mount_err;
866
867 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
868 if (!mountdata_copy)
869 goto cifs_parse_mount_err;
1da177e4 870
b946845a 871 options = mountdata_copy;
4906e50b 872 end = options + strlen(options);
50c2f753 873 if (strncmp(options, "sep=", 4) == 0) {
fb8c4b14 874 if (options[4] != 0) {
1da177e4
LT		 875 separator[0] = options[4];
876 options += 5;
877 } else {
b6b38f70 878 cFYI(1, "Null separator not allowed");
1da177e4
LT		 879 }
880 }
50c2f753 881
1da177e4
LT		 882 while ((data = strsep(&options, separator)) != NULL) {
883 if (!*data)
884 continue;
885 if ((value = strchr(data, '=')) != NULL)
886 *value++ = '\0';
887
50c2f753
SF		 888 /* Have to parse this before we parse for "user" */
889 if (strnicmp(data, "user_xattr", 10) == 0) {
1da177e4 890 vol->no_xattr = 0;
50c2f753 891 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
1da177e4
LT		 892 vol->no_xattr = 1;
893 } else if (strnicmp(data, "user", 4) == 0) {
4b952a9b 894 if (!value) {
1da177e4
LT		 895 printk(KERN_WARNING
896 "CIFS: invalid or missing username\n");
b946845a 897 goto cifs_parse_mount_err;
fb8c4b14 898 } else if (!*value) {
4b952a9b
SF		 899 /* null user, ie anonymous, authentication */
900 vol->nullauth = 1;
1da177e4 901 }
8727c8a8
SF		 902 if (strnlen(value, MAX_USERNAME_SIZE) <
903 MAX_USERNAME_SIZE) {
b946845a
SF		 904 vol->username = kstrdup(value, GFP_KERNEL);
905 if (!vol->username) {
906 printk(KERN_WARNING "CIFS: no memory "
907 "for username\n");
908 goto cifs_parse_mount_err;
909 }
1da177e4
LT		 910 } else {
911 printk(KERN_WARNING "CIFS: username too long\n");
b946845a 912 goto cifs_parse_mount_err;
1da177e4
LT		 913 }
914 } else if (strnicmp(data, "pass", 4) == 0) {
915 if (!value) {
916 vol->password = NULL;
917 continue;
fb8c4b14 918 } else if (value[0] == 0) {
1da177e4
LT		 919 /* check if string begins with double comma
920 since that would mean the password really
921 does start with a comma, and would not
922 indicate an empty string */
fb8c4b14 923 if (value[1] != separator[0]) {
1da177e4
LT		 924 vol->password = NULL;
925 continue;
926 }
927 }
928 temp_len = strlen(value);
929 /* removed password length check, NTLM passwords
930 can be arbitrarily long */
931
50c2f753 932 /* if comma in password, the string will be
1da177e4
LT		 933 prematurely null terminated. Commas in password are
934 specified across the cifs mount interface by a double
935 comma ie ,, and a comma used as in other cases ie ','
936 as a parameter delimiter/separator is single and due
937 to the strsep above is temporarily zeroed. */
938
939 /* NB: password legally can have multiple commas and
940 the only illegal character in a password is null */
941
50c2f753 942 if ((value[temp_len] == 0) &&
4906e50b 943 (value + temp_len < end) &&
09d1db5c 944 (value[temp_len+1] == separator[0])) {
1da177e4
LT		 945 /* reinsert comma */
946 value[temp_len] = separator[0];
50c2f753
SF		 947 temp_len += 2; /* move after second comma */
948 while (value[temp_len] != 0) {
1da177e4 949 if (value[temp_len] == separator[0]) {
50c2f753 950 if (value[temp_len+1] ==
09d1db5c
SF		 951 separator[0]) {
952 /* skip second comma */
953 temp_len++;
50c2f753 954 } else {
1da177e4
LT		 955 /* single comma indicating start
956 of next parm */
957 break;
958 }
959 }
960 temp_len++;
961 }
fb8c4b14 962 if (value[temp_len] == 0) {
1da177e4
LT		 963 options = NULL;
964 } else {
965 value[temp_len] = 0;
966 /* point option to start of next parm */
967 options = value + temp_len + 1;
968 }
50c2f753 969 /* go from value to value + temp_len condensing
1da177e4
LT		 970 double commas to singles. Note that this ends up
971 allocating a few bytes too many, which is ok */
e915fc49 972 vol->password = kzalloc(temp_len, GFP_KERNEL);
fb8c4b14 973 if (vol->password == NULL) {
50c2f753
SF		 974 printk(KERN_WARNING "CIFS: no memory "
975 "for password\n");
b946845a 976 goto cifs_parse_mount_err;
433dc24f 977 }
50c2f753 978 for (i = 0, j = 0; i < temp_len; i++, j++) {
1da177e4 979 vol->password[j] = value[i];
fb8c4b14 980 if (value[i] == separator[0]
09d1db5c 981 && value[i+1] == separator[0]) {
1da177e4
LT		 982 /* skip second comma */
983 i++;
984 }
985 }
986 vol->password[j] = 0;
987 } else {
e915fc49 988 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
fb8c4b14 989 if (vol->password == NULL) {
50c2f753
SF		 990 printk(KERN_WARNING "CIFS: no memory "
991 "for password\n");
b946845a 992 goto cifs_parse_mount_err;
433dc24f 993 }
1da177e4
LT		 994 strcpy(vol->password, value);
995 }
58f7f68f
JL		 996 } else if (!strnicmp(data, "ip", 2) ||
997 !strnicmp(data, "addr", 4)) {
1da177e4
LT		 998 if (!value || !*value) {
999 vol->UNCip = NULL;
50b64e3b
JL		 1000 } else if (strnlen(value, INET6_ADDRSTRLEN) <
1001 INET6_ADDRSTRLEN) {
b946845a
SF		 1002 vol->UNCip = kstrdup(value, GFP_KERNEL);
1003 if (!vol->UNCip) {
1004 printk(KERN_WARNING "CIFS: no memory "
1005 "for UNC IP\n");
1006 goto cifs_parse_mount_err;
1007 }
1da177e4 1008 } else {
50c2f753
SF		 1009 printk(KERN_WARNING "CIFS: ip address "
1010 "too long\n");
b946845a 1011 goto cifs_parse_mount_err;
1da177e4 1012 }
50c2f753
SF		 1013 } else if (strnicmp(data, "sec", 3) == 0) {
1014 if (!value || !*value) {
b6b38f70 1015 cERROR(1, "no security value specified");
50c2f753
SF		 1016 continue;
1017 } else if (strnicmp(value, "krb5i", 5) == 0) {
1018 vol->secFlg |= CIFSSEC_MAY_KRB5 |
189acaae 1019 CIFSSEC_MUST_SIGN;
bf820679 1020 } else if (strnicmp(value, "krb5p", 5) == 0) {
50c2f753
SF		 1021 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1022 CIFSSEC_MAY_KRB5; */
b6b38f70 1023 cERROR(1, "Krb5 cifs privacy not supported");
b946845a 1024 goto cifs_parse_mount_err;
bf820679 1025 } else if (strnicmp(value, "krb5", 4) == 0) {
750d1151 1026 vol->secFlg |= CIFSSEC_MAY_KRB5;
ac683924
SF		 1027 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1028 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1029 CIFSSEC_MUST_SIGN;
1030 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1031 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
bf820679 1032 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
750d1151 1033 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
189acaae 1034 CIFSSEC_MUST_SIGN;
bf820679 1035 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
750d1151 1036 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
bf820679 1037 } else if (strnicmp(value, "ntlmi", 5) == 0) {
750d1151 1038 vol->secFlg |= CIFSSEC_MAY_NTLM |
189acaae 1039 CIFSSEC_MUST_SIGN;
bf820679
SF		 1040 } else if (strnicmp(value, "ntlm", 4) == 0) {
1041 /* ntlm is default so can be turned off too */
750d1151 1042 vol->secFlg |= CIFSSEC_MAY_NTLM;
bf820679 1043 } else if (strnicmp(value, "nontlm", 6) == 0) {
189acaae 1044 /* BB is there a better way to do this? */
750d1151 1045 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
189acaae
SF		 1046#ifdef CONFIG_CIFS_WEAK_PW_HASH
1047 } else if (strnicmp(value, "lanman", 6) == 0) {
50c2f753 1048 vol->secFlg |= CIFSSEC_MAY_LANMAN;
189acaae 1049#endif
bf820679 1050 } else if (strnicmp(value, "none", 4) == 0) {
189acaae 1051 vol->nullauth = 1;
50c2f753 1052 } else {
b6b38f70 1053 cERROR(1, "bad security option: %s", value);
b946845a 1054 goto cifs_parse_mount_err;
50c2f753 1055 }
1cb06d0b
SF		 1056 } else if (strnicmp(data, "vers", 3) == 0) {
1057 if (!value || !*value) {
1058 cERROR(1, "no protocol version specified"
1059 " after vers= mount option");
1060 } else if ((strnicmp(value, "cifs", 4) == 0) ||
1061 (strnicmp(value, "1", 1) == 0)) {
1062 /* this is the default */
1063 continue;
1cb06d0b 1064 }
1da177e4
LT		 1065 } else if ((strnicmp(data, "unc", 3) == 0)
1066 || (strnicmp(data, "target", 6) == 0)
1067 || (strnicmp(data, "path", 4) == 0)) {
1068 if (!value || !*value) {
50c2f753
SF		 1069 printk(KERN_WARNING "CIFS: invalid path to "
1070 "network resource\n");
b946845a 1071 goto cifs_parse_mount_err;
1da177e4
LT		 1072 }
1073 if ((temp_len = strnlen(value, 300)) < 300) {
50c2f753 1074 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
4523cc30 1075 if (vol->UNC == NULL)
b946845a 1076 goto cifs_parse_mount_err;
50c2f753 1077 strcpy(vol->UNC, value);
1da177e4
LT		 1078 if (strncmp(vol->UNC, "//", 2) == 0) {
1079 vol->UNC[0] = '\\';
1080 vol->UNC[1] = '\\';
50c2f753 1081 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1da177e4 1082 printk(KERN_WARNING
50c2f753
SF		 1083 "CIFS: UNC Path does not begin "
1084 "with // or \\\\ \n");
b946845a 1085 goto cifs_parse_mount_err;
1da177e4
LT		 1086 }
1087 } else {
1088 printk(KERN_WARNING "CIFS: UNC name too long\n");
b946845a 1089 goto cifs_parse_mount_err;
1da177e4
LT		 1090 }
1091 } else if ((strnicmp(data, "domain", 3) == 0)
1092 || (strnicmp(data, "workgroup", 5) == 0)) {
1093 if (!value || !*value) {
1094 printk(KERN_WARNING "CIFS: invalid domain name\n");
b946845a 1095 goto cifs_parse_mount_err;
1da177e4
LT		 1096 }
1097 /* BB are there cases in which a comma can be valid in
1098 a domain name and need special handling? */
3979877e 1099 if (strnlen(value, 256) < 256) {
b946845a
SF		 1100 vol->domainname = kstrdup(value, GFP_KERNEL);
1101 if (!vol->domainname) {
1102 printk(KERN_WARNING "CIFS: no memory "
1103 "for domainname\n");
1104 goto cifs_parse_mount_err;
1105 }
b6b38f70 1106 cFYI(1, "Domain name set");
1da177e4 1107 } else {
50c2f753
SF		 1108 printk(KERN_WARNING "CIFS: domain name too "
1109 "long\n");
b946845a 1110 goto cifs_parse_mount_err;
1da177e4 1111 }
3eb9a889
BG		 1112 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1113 vol->srcaddr.ss_family = AF_UNSPEC;
1114
1115 if (!value || !*value) {
1116 printk(KERN_WARNING "CIFS: srcaddr value"
1117 " not specified.\n");
b946845a 1118 goto cifs_parse_mount_err;
3eb9a889
BG		 1119 }
1120 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1121 value, strlen(value));
b235f371 1122 if (i == 0) {
3eb9a889
BG		 1123 printk(KERN_WARNING "CIFS: Could not parse"
1124 " srcaddr: %s\n",
1125 value);
b946845a 1126 goto cifs_parse_mount_err;
3eb9a889 1127 }
50c2f753
SF		 1128 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1129 if (!value || !*value) {
1130 printk(KERN_WARNING
1131 "CIFS: invalid path prefix\n");
b946845a 1132 goto cifs_parse_mount_err;
50c2f753
SF		 1133 }
1134 if ((temp_len = strnlen(value, 1024)) < 1024) {
4523cc30 1135 if (value[0] != '/')
2fe87f02 1136 temp_len++; /* missing leading slash */
50c2f753
SF		 1137 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1138 if (vol->prepath == NULL)
b946845a 1139 goto cifs_parse_mount_err;
4523cc30 1140 if (value[0] != '/') {
2fe87f02 1141 vol->prepath[0] = '/';
50c2f753 1142 strcpy(vol->prepath+1, value);
2fe87f02 1143 } else
50c2f753 1144 strcpy(vol->prepath, value);
b6b38f70 1145 cFYI(1, "prefix path %s", vol->prepath);
50c2f753
SF		 1146 } else {
1147 printk(KERN_WARNING "CIFS: prefix too long\n");
b946845a 1148 goto cifs_parse_mount_err;
50c2f753 1149 }
1da177e4
LT		 1150 } else if (strnicmp(data, "iocharset", 9) == 0) {
1151 if (!value || !*value) {
63135e08
SF		 1152 printk(KERN_WARNING "CIFS: invalid iocharset "
1153 "specified\n");
b946845a 1154 goto cifs_parse_mount_err;
1da177e4
LT		 1155 }
1156 if (strnlen(value, 65) < 65) {
b946845a
SF		 1157 if (strnicmp(value, "default", 7)) {
1158 vol->iocharset = kstrdup(value,
1159 GFP_KERNEL);
1160
1161 if (!vol->iocharset) {
1162 printk(KERN_WARNING "CIFS: no "
1163 "memory for"
1164 "charset\n");
1165 goto cifs_parse_mount_err;
1166 }
1167 }
50c2f753
SF		 1168 /* if iocharset not set then load_nls_default
1169 is used by caller */
b6b38f70 1170 cFYI(1, "iocharset set to %s", value);
1da177e4 1171 } else {
63135e08
SF		 1172 printk(KERN_WARNING "CIFS: iocharset name "
1173 "too long.\n");
b946845a 1174 goto cifs_parse_mount_err;
1da177e4 1175 }
9b9d6b24
JL		 1176 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1177 vol->linux_uid = simple_strtoul(value, &value, 0);
1178 uid_specified = true;
bd763319
JL		 1179 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1180 vol->cred_uid = simple_strtoul(value, &value, 0);
9b9d6b24
JL		 1181 } else if (!strnicmp(data, "forceuid", 8)) {
1182 override_uid = 1;
1183 } else if (!strnicmp(data, "noforceuid", 10)) {
1184 override_uid = 0;
1185 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1186 vol->linux_gid = simple_strtoul(value, &value, 0);
1187 gid_specified = true;
1188 } else if (!strnicmp(data, "forcegid", 8)) {
1189 override_gid = 1;
1190 } else if (!strnicmp(data, "noforcegid", 10)) {
1191 override_gid = 0;
1da177e4
LT		 1192 } else if (strnicmp(data, "file_mode", 4) == 0) {
1193 if (value && *value) {
1194 vol->file_mode =
1195 simple_strtoul(value, &value, 0);
1196 }
1197 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1198 if (value && *value) {
1199 vol->dir_mode =
1200 simple_strtoul(value, &value, 0);
1201 }
1202 } else if (strnicmp(data, "dirmode", 4) == 0) {
1203 if (value && *value) {
1204 vol->dir_mode =
1205 simple_strtoul(value, &value, 0);
1206 }
1207 } else if (strnicmp(data, "port", 4) == 0) {
1208 if (value && *value) {
1209 vol->port =
1210 simple_strtoul(value, &value, 0);
1211 }
1212 } else if (strnicmp(data, "rsize", 5) == 0) {
1213 if (value && *value) {
1214 vol->rsize =
1215 simple_strtoul(value, &value, 0);
1216 }
1217 } else if (strnicmp(data, "wsize", 5) == 0) {
1218 if (value && *value) {
1219 vol->wsize =
1220 simple_strtoul(value, &value, 0);
1221 }
1222 } else if (strnicmp(data, "sockopt", 5) == 0) {
6a5fa236 1223 if (!value || !*value) {
b6b38f70 1224 cERROR(1, "no socket option specified");
6a5fa236
SF		 1225 continue;
1226 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1227 vol->sockopt_tcp_nodelay = 1;
1da177e4
LT		 1228 }
1229 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1230 if (!value || !*value || (*value == ' ')) {
b6b38f70 1231 cFYI(1, "invalid (empty) netbiosname");
1da177e4 1232 } else {
1397f2ee
JL		 1233 memset(vol->source_rfc1001_name, 0x20,
1234 RFC1001_NAME_LEN);
1235 /*
1236 * FIXME: are there cases in which a comma can
1237 * be valid in workstation netbios name (and
1238 * need special handling)?
1239 */
1240 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1241 /* don't ucase netbiosname for user */
50c2f753 1242 if (value[i] == 0)
1da177e4 1243 break;
1397f2ee 1244 vol->source_rfc1001_name[i] = value[i];
1da177e4
LT		 1245 }
1246 /* The string has 16th byte zero still from
1247 set at top of the function */
1397f2ee 1248 if (i == RFC1001_NAME_LEN && value[i] != 0)
50c2f753
SF		 1249 printk(KERN_WARNING "CIFS: netbiosname"
1250 " longer than 15 truncated.\n");
a10faeb2
SF		 1251 }
1252 } else if (strnicmp(data, "servern", 7) == 0) {
1253 /* servernetbiosname specified override *SMBSERVER */
1254 if (!value || !*value || (*value == ' ')) {
b6b38f70 1255 cFYI(1, "empty server netbiosname specified");
a10faeb2
SF		 1256 } else {
1257 /* last byte, type, is 0x20 for servr type */
1397f2ee
JL		 1258 memset(vol->target_rfc1001_name, 0x20,
1259 RFC1001_NAME_LEN_WITH_NULL);
a10faeb2 1260
50c2f753 1261 for (i = 0; i < 15; i++) {
a10faeb2 1262 /* BB are there cases in which a comma can be
50c2f753
SF		 1263 valid in this workstation netbios name
1264 (and need special handling)? */
a10faeb2 1265
50c2f753
SF		 1266 /* user or mount helper must uppercase
1267 the netbiosname */
1268 if (value[i] == 0)
a10faeb2
SF		 1269 break;
1270 else
50c2f753
SF		 1271 vol->target_rfc1001_name[i] =
1272 value[i];
a10faeb2
SF		 1273 }
1274 /* The string has 16th byte zero still from
1275 set at top of the function */
1397f2ee 1276 if (i == RFC1001_NAME_LEN && value[i] != 0)
50c2f753
SF		 1277 printk(KERN_WARNING "CIFS: server net"
1278 "biosname longer than 15 truncated.\n");
1da177e4 1279 }
6d20e840
SJ		 1280 } else if (strnicmp(data, "actimeo", 7) == 0) {
1281 if (value && *value) {
1282 vol->actimeo = HZ * simple_strtoul(value,
1283 &value, 0);
1284 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1285 cERROR(1, "CIFS: attribute cache"
1286 "timeout too large");
b946845a 1287 goto cifs_parse_mount_err;
6d20e840
SJ		 1288 }
1289 }
1da177e4
LT		 1290 } else if (strnicmp(data, "credentials", 4) == 0) {
1291 /* ignore */
1292 } else if (strnicmp(data, "version", 3) == 0) {
1293 /* ignore */
50c2f753 1294 } else if (strnicmp(data, "guest", 5) == 0) {
1da177e4 1295 /* ignore */
71a394fa
SF		 1296 } else if (strnicmp(data, "rw", 2) == 0) {
1297 /* ignore */
1298 } else if (strnicmp(data, "ro", 2) == 0) {
1299 /* ignore */
edf1ae40
SF		 1300 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1301 vol->noblocksnd = 1;
1302 } else if (strnicmp(data, "noautotune", 10) == 0) {
1303 vol->noautotune = 1;
1da177e4
LT		 1304 } else if ((strnicmp(data, "suid", 4) == 0) ||
1305 (strnicmp(data, "nosuid", 6) == 0) ||
1306 (strnicmp(data, "exec", 4) == 0) ||
1307 (strnicmp(data, "noexec", 6) == 0) ||
1308 (strnicmp(data, "nodev", 5) == 0) ||
1309 (strnicmp(data, "noauto", 6) == 0) ||
1310 (strnicmp(data, "dev", 3) == 0)) {
1311 /* The mount tool or mount.cifs helper (if present)
50c2f753
SF		 1312 uses these opts to set flags, and the flags are read
1313 by the kernel vfs layer before we get here (ie
1314 before read super) so there is no point trying to
1315 parse these options again and set anything and it
1316 is ok to just ignore them */
1da177e4 1317 continue;
1da177e4
LT		 1318 } else if (strnicmp(data, "hard", 4) == 0) {
1319 vol->retry = 1;
1320 } else if (strnicmp(data, "soft", 4) == 0) {
1321 vol->retry = 0;
1322 } else if (strnicmp(data, "perm", 4) == 0) {
1323 vol->noperm = 0;
1324 } else if (strnicmp(data, "noperm", 6) == 0) {
1325 vol->noperm = 1;
6a0b4824
SF		 1326 } else if (strnicmp(data, "mapchars", 8) == 0) {
1327 vol->remap = 1;
1328 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1329 vol->remap = 0;
50c2f753
SF		 1330 } else if (strnicmp(data, "sfu", 3) == 0) {
1331 vol->sfu_emul = 1;
1332 } else if (strnicmp(data, "nosfu", 5) == 0) {
1333 vol->sfu_emul = 0;
2c1b8615
SF		 1334 } else if (strnicmp(data, "nodfs", 5) == 0) {
1335 vol->nodfs = 1;
ac67055e
JA		 1336 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1337 vol->posix_paths = 1;
1338 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1339 vol->posix_paths = 0;
c18c842b
SF		 1340 } else if (strnicmp(data, "nounix", 6) == 0) {
1341 vol->no_linux_ext = 1;
1342 } else if (strnicmp(data, "nolinux", 7) == 0) {
1343 vol->no_linux_ext = 1;
50c2f753 1344 } else if ((strnicmp(data, "nocase", 6) == 0) ||
a10faeb2 1345 (strnicmp(data, "ignorecase", 10) == 0)) {
50c2f753 1346 vol->nocase = 1;
f636a348
JL		 1347 } else if (strnicmp(data, "mand", 4) == 0) {
1348 /* ignore */
1349 } else if (strnicmp(data, "nomand", 6) == 0) {
1350 /* ignore */
1351 } else if (strnicmp(data, "_netdev", 7) == 0) {
1352 /* ignore */
c46fa8ac
SF		 1353 } else if (strnicmp(data, "brl", 3) == 0) {
1354 vol->nobrl = 0;
50c2f753 1355 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1c955187 1356 (strnicmp(data, "nolock", 6) == 0)) {
c46fa8ac 1357 vol->nobrl = 1;
d3485d37
SF		 1358 /* turn off mandatory locking in mode
1359 if remote locking is turned off since the
1360 local vfs will do advisory */
50c2f753
SF		 1361 if (vol->file_mode ==
1362 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
d3485d37 1363 vol->file_mode = S_IALLUGO;
13a6e42a
SF		 1364 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1365 /* will take the shorter form "forcemand" as well */
1366 /* This mount option will force use of mandatory
1367 (DOS/Windows style) byte range locks, instead of
1368 using posix advisory byte range locks, even if the
1369 Unix extensions are available and posix locks would
1370 be supported otherwise. If Unix extensions are not
1371 negotiated this has no effect since mandatory locks
1372 would be used (mandatory locks is all that those
1373 those servers support) */
1374 vol->mand_lock = 1;
1da177e4
LT		 1375 } else if (strnicmp(data, "setuids", 7) == 0) {
1376 vol->setuids = 1;
1377 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1378 vol->setuids = 0;
d0a9c078
JL		 1379 } else if (strnicmp(data, "dynperm", 7) == 0) {
1380 vol->dynperm = true;
1381 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1382 vol->dynperm = false;
1da177e4
LT		 1383 } else if (strnicmp(data, "nohard", 6) == 0) {
1384 vol->retry = 0;
1385 } else if (strnicmp(data, "nosoft", 6) == 0) {
1386 vol->retry = 1;
1387 } else if (strnicmp(data, "nointr", 6) == 0) {
1388 vol->intr = 0;
1389 } else if (strnicmp(data, "intr", 4) == 0) {
1390 vol->intr = 1;
be652445
SF		 1391 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1392 vol->nostrictsync = 1;
1393 } else if (strnicmp(data, "strictsync", 10) == 0) {
1394 vol->nostrictsync = 0;
50c2f753 1395 } else if (strnicmp(data, "serverino", 7) == 0) {
1da177e4 1396 vol->server_ino = 1;
50c2f753 1397 } else if (strnicmp(data, "noserverino", 9) == 0) {
1da177e4 1398 vol->server_ino = 0;
50c2f753 1399 } else if (strnicmp(data, "cifsacl", 7) == 0) {
0a4b92c0
SF		 1400 vol->cifs_acl = 1;
1401 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1402 vol->cifs_acl = 0;
50c2f753 1403 } else if (strnicmp(data, "acl", 3) == 0) {
1da177e4 1404 vol->no_psx_acl = 0;
50c2f753 1405 } else if (strnicmp(data, "noacl", 5) == 0) {
1da177e4 1406 vol->no_psx_acl = 1;
84210e91
SF		 1407 } else if (strnicmp(data, "locallease", 6) == 0) {
1408 vol->local_lease = 1;
50c2f753 1409 } else if (strnicmp(data, "sign", 4) == 0) {
750d1151 1410 vol->secFlg |= CIFSSEC_MUST_SIGN;
95b1cb90
SF		 1411 } else if (strnicmp(data, "seal", 4) == 0) {
1412 /* we do not do the following in secFlags because seal
1413 is a per tree connection (mount) not a per socket
1414 or per-smb connection option in the protocol */
1415 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1416 vol->seal = 1;
50c2f753 1417 } else if (strnicmp(data, "direct", 6) == 0) {
1da177e4 1418 vol->direct_io = 1;
50c2f753 1419 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1da177e4 1420 vol->direct_io = 1;
d39454ff
PS		 1421 } else if (strnicmp(data, "strictcache", 11) == 0) {
1422 vol->strict_io = 1;
1da177e4 1423 } else if (strnicmp(data, "noac", 4) == 0) {
50c2f753
SF		 1424 printk(KERN_WARNING "CIFS: Mount option noac not "
1425 "supported. Instead set "
1426 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
fa1df75d 1427 } else if (strnicmp(data, "fsc", 3) == 0) {
607a569d
SJ		 1428#ifndef CONFIG_CIFS_FSCACHE
1429 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1430 "kernel config option set");
b946845a 1431 goto cifs_parse_mount_err;
607a569d 1432#endif
fa1df75d 1433 vol->fsc = true;
736a3320
SM		 1434 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1435 vol->mfsymlinks = true;
0eb8a132
JL		 1436 } else if (strnicmp(data, "multiuser", 8) == 0) {
1437 vol->multiuser = true;
1da177e4 1438 } else
50c2f753
SF		 1439 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1440 data);
1da177e4
LT		 1441 }
1442 if (vol->UNC == NULL) {
4523cc30 1443 if (devname == NULL) {
50c2f753
SF		 1444 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1445 "target\n");
b946845a 1446 goto cifs_parse_mount_err;
1da177e4
LT		 1447 }
1448 if ((temp_len = strnlen(devname, 300)) < 300) {
50c2f753 1449 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
4523cc30 1450 if (vol->UNC == NULL)
b946845a 1451 goto cifs_parse_mount_err;
50c2f753 1452 strcpy(vol->UNC, devname);
1da177e4
LT		 1453 if (strncmp(vol->UNC, "//", 2) == 0) {
1454 vol->UNC[0] = '\\';
1455 vol->UNC[1] = '\\';
1456 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
50c2f753
SF		 1457 printk(KERN_WARNING "CIFS: UNC Path does not "
1458 "begin with // or \\\\ \n");
b946845a 1459 goto cifs_parse_mount_err;
1da177e4 1460 }
7c5e628f
IM		 1461 value = strpbrk(vol->UNC+2, "/\\");
1462 if (value)
1463 *value = '\\';
1da177e4
LT		 1464 } else {
1465 printk(KERN_WARNING "CIFS: UNC name too long\n");
b946845a 1466 goto cifs_parse_mount_err;
1da177e4
LT		 1467 }
1468 }
0eb8a132
JL		 1469
1470 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1471 cERROR(1, "Multiuser mounts currently require krb5 "
1472 "authentication!");
b946845a 1473 goto cifs_parse_mount_err;
0eb8a132
JL		 1474 }
1475
fb8c4b14 1476 if (vol->UNCip == NULL)
1da177e4
LT		 1477 vol->UNCip = &vol->UNC[2];
1478
9b9d6b24
JL		 1479 if (uid_specified)
1480 vol->override_uid = override_uid;
1481 else if (override_uid == 1)
1482 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1483 "specified with no uid= option.\n");
1484
1485 if (gid_specified)
1486 vol->override_gid = override_gid;
1487 else if (override_gid == 1)
1488 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1489 "specified with no gid= option.\n");
1490
b946845a 1491 kfree(mountdata_copy);
1da177e4 1492 return 0;
b946845a
SF		 1493
1494cifs_parse_mount_err:
1495 kfree(mountdata_copy);
1496 return 1;
1da177e4
LT		 1497}
1498
3eb9a889
BG		 1499/** Returns true if srcaddr isn't specified and rhs isn't
1500 * specified, or if srcaddr is specified and
1501 * matches the IP address of the rhs argument.
1502 */
1503static bool
1504srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1505{
1506 switch (srcaddr->sa_family) {
1507 case AF_UNSPEC:
1508 return (rhs->sa_family == AF_UNSPEC);
1509 case AF_INET: {
1510 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1511 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1512 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1513 }
1514 case AF_INET6: {
1515 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1516 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1517 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1518 }
1519 default:
1520 WARN_ON(1);
1521 return false; /* don't expect to be here */
1522 }
1523}
1524
4b886136
PS		 1525/*
1526 * If no port is specified in addr structure, we try to match with 445 port
1527 * and if it fails - with 139 ports. It should be called only if address
1528 * families of server and addr are equal.
1529 */
1530static bool
1531match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1532{
6da97910 1533 __be16 port, *sport;
4b886136
PS		 1534
1535 switch (addr->sa_family) {
1536 case AF_INET:
1537 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1538 port = ((struct sockaddr_in *) addr)->sin_port;
1539 break;
1540 case AF_INET6:
1541 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1542 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1543 break;
1544 default:
1545 WARN_ON(1);
1546 return false;
1547 }
1548
1549 if (!port) {
1550 port = htons(CIFS_PORT);
1551 if (port == *sport)
1552 return true;
1553
1554 port = htons(RFC1001_PORT);
1555 }
1556
1557 return port == *sport;
1558}
3eb9a889 1559
4515148e 1560static bool
3eb9a889
BG		 1561match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1562 struct sockaddr *srcaddr)
4515148e 1563{
4515148e 1564 switch (addr->sa_family) {
a9f1b85e
PS		 1565 case AF_INET: {
1566 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1567 struct sockaddr_in *srv_addr4 =
1568 (struct sockaddr_in *)&server->dstaddr;
1569
1570 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
4515148e 1571 return false;
4515148e 1572 break;
a9f1b85e
PS		 1573 }
1574 case AF_INET6: {
1575 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1576 struct sockaddr_in6 *srv_addr6 =
1577 (struct sockaddr_in6 *)&server->dstaddr;
1578
4515148e 1579 if (!ipv6_addr_equal(&addr6->sin6_addr,
a9f1b85e 1580 &srv_addr6->sin6_addr))
4515148e 1581 return false;
a9f1b85e 1582 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
4515148e 1583 return false;
4515148e
JL		 1584 break;
1585 }
a9f1b85e
PS		 1586 default:
1587 WARN_ON(1);
1588 return false; /* don't expect to be here */
1589 }
4515148e 1590
3eb9a889
BG		 1591 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1592 return false;
1593
4515148e
JL		 1594 return true;
1595}
1596
daf5b0b6
JL		 1597static bool
1598match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1599{
1600 unsigned int secFlags;
1601
1602 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1603 secFlags = vol->secFlg;
1604 else
1605 secFlags = global_secflags | vol->secFlg;
1606
1607 switch (server->secType) {
1608 case LANMAN:
1609 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1610 return false;
1611 break;
1612 case NTLMv2:
1613 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1614 return false;
1615 break;
1616 case NTLM:
1617 if (!(secFlags & CIFSSEC_MAY_NTLM))
1618 return false;
1619 break;
1620 case Kerberos:
1621 if (!(secFlags & CIFSSEC_MAY_KRB5))
1622 return false;
1623 break;
1624 case RawNTLMSSP:
1625 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1626 return false;
1627 break;
1628 default:
1629 /* shouldn't happen */
1630 return false;
1631 }
1632
25985edc 1633 /* now check if signing mode is acceptable */
daf5b0b6
JL		 1634 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1635 (server->secMode & SECMODE_SIGN_REQUIRED))
1636 return false;
1637 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1638 (server->secMode &
1639 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1640 return false;
1641
1642 return true;
1643}
1644
37bb04e5
PS		 1645static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
1646 struct smb_vol *vol)
1647{
1648 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1649 return 0;
1650
1651 if (!match_address(server, addr,
1652 (struct sockaddr *)&vol->srcaddr))
1653 return 0;
1654
1655 if (!match_port(server, addr))
1656 return 0;
1657
1658 if (!match_security(server, vol))
1659 return 0;
1660
1661 return 1;
1662}
1663
e7ddee90 1664static struct TCP_Server_Info *
daf5b0b6 1665cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1da177e4 1666{
e7ddee90 1667 struct TCP_Server_Info *server;
e7ddee90 1668
3f9bcca7 1669 spin_lock(&cifs_tcp_ses_lock);
4515148e 1670 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
37bb04e5 1671 if (!match_server(server, addr, vol))
daf5b0b6
JL		 1672 continue;
1673
e7ddee90 1674 ++server->srv_count;
3f9bcca7 1675 spin_unlock(&cifs_tcp_ses_lock);
b6b38f70 1676 cFYI(1, "Existing tcp session with server found");
e7ddee90 1677 return server;
1da177e4 1678 }
3f9bcca7 1679 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 1680 return NULL;
1681}
1b20d672 1682
14fbf50d 1683static void
e7ddee90 1684cifs_put_tcp_session(struct TCP_Server_Info *server)
1da177e4 1685{
e7ddee90 1686 struct task_struct *task;
1b20d672 1687
3f9bcca7 1688 spin_lock(&cifs_tcp_ses_lock);
e7ddee90 1689 if (--server->srv_count > 0) {
3f9bcca7 1690 spin_unlock(&cifs_tcp_ses_lock);
e7ddee90 1691 return;
1da177e4 1692 }
1b20d672 1693
f1d0c998
RL		 1694 put_net(cifs_net_ns(server));
1695
e7ddee90 1696 list_del_init(&server->tcp_ses_list);
3f9bcca7 1697 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 1698
c74093b6
JL		 1699 cancel_delayed_work_sync(&server->echo);
1700
e7ddee90
JL		 1701 spin_lock(&GlobalMid_Lock);
1702 server->tcpStatus = CifsExiting;
1703 spin_unlock(&GlobalMid_Lock);
dea570e0 1704
d2b91521 1705 cifs_crypto_shash_release(server);
488f1d2d
SJ		 1706 cifs_fscache_release_client_cookie(server);
1707
21e73393
SP		 1708 kfree(server->session_key.response);
1709 server->session_key.response = NULL;
1710 server->session_key.len = 0;
1711
e7ddee90
JL		 1712 task = xchg(&server->tsk, NULL);
1713 if (task)
1714 force_sig(SIGKILL, task);
1da177e4
LT		 1715}
1716
63c038c2
JL		 1717static struct TCP_Server_Info *
1718cifs_get_tcp_session(struct smb_vol *volume_info)
1719{
1720 struct TCP_Server_Info *tcp_ses = NULL;
a9ac49d3 1721 struct sockaddr_storage addr;
63c038c2
JL		 1722 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1723 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1724 int rc;
1725
a9ac49d3 1726 memset(&addr, 0, sizeof(struct sockaddr_storage));
63c038c2 1727
b6b38f70 1728 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
63c038c2 1729
1e68b2b2 1730 if (volume_info->UNCip && volume_info->UNC) {
50d97160
JL		 1731 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1732 volume_info->UNCip,
67b7626a 1733 strlen(volume_info->UNCip),
50d97160 1734 volume_info->port);
1e68b2b2 1735 if (!rc) {
63c038c2
JL		 1736 /* we failed translating address */
1737 rc = -EINVAL;
1738 goto out_err;
1739 }
63c038c2
JL		 1740 } else if (volume_info->UNCip) {
1741 /* BB using ip addr as tcp_ses name to connect to the
1742 DFS root below */
b6b38f70 1743 cERROR(1, "Connecting to DFS root not implemented yet");
63c038c2
JL		 1744 rc = -EINVAL;
1745 goto out_err;
1746 } else /* which tcp_sess DFS root would we conect to */ {
b6b38f70
JP		 1747 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1748 "unc=//192.168.1.100/public) specified");
63c038c2
JL		 1749 rc = -EINVAL;
1750 goto out_err;
1751 }
1752
1753 /* see if we already have a matching tcp_ses */
daf5b0b6 1754 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
63c038c2
JL		 1755 if (tcp_ses)
1756 return tcp_ses;
1757
1758 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1759 if (!tcp_ses) {
1760 rc = -ENOMEM;
1761 goto out_err;
1762 }
1763
d2b91521
SP		 1764 rc = cifs_crypto_shash_allocate(tcp_ses);
1765 if (rc) {
1766 cERROR(1, "could not setup hash structures rc %d", rc);
1767 goto out_err;
1768 }
1769
f1d0c998 1770 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
63c038c2
JL		 1771 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1772 if (IS_ERR(tcp_ses->hostname)) {
1773 rc = PTR_ERR(tcp_ses->hostname);
f7c5445a 1774 goto out_err_crypto_release;
63c038c2
JL		 1775 }
1776
1777 tcp_ses->noblocksnd = volume_info->noblocksnd;
1778 tcp_ses->noautotune = volume_info->noautotune;
6a5fa236 1779 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
63c038c2
JL		 1780 atomic_set(&tcp_ses->inFlight, 0);
1781 init_waitqueue_head(&tcp_ses->response_q);
1782 init_waitqueue_head(&tcp_ses->request_q);
1783 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1784 mutex_init(&tcp_ses->srv_mutex);
1785 memcpy(tcp_ses->workstation_RFC1001_name,
1786 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1787 memcpy(tcp_ses->server_RFC1001_name,
1788 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
5d0d2882 1789 tcp_ses->session_estab = false;
63c038c2 1790 tcp_ses->sequence_number = 0;
fda35943 1791 tcp_ses->lstrp = jiffies;
63c038c2
JL		 1792 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1793 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
c74093b6 1794 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
63c038c2
JL		 1795
1796 /*
1797 * at this point we are the only ones with the pointer
1798 * to the struct since the kernel thread not created yet
1799 * no need to spinlock this init of tcpStatus or srv_count
1800 */
1801 tcp_ses->tcpStatus = CifsNew;
3eb9a889
BG		 1802 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1803 sizeof(tcp_ses->srcaddr));
63c038c2
JL		 1804 ++tcp_ses->srv_count;
1805
a9ac49d3 1806 if (addr.ss_family == AF_INET6) {
b6b38f70 1807 cFYI(1, "attempting ipv6 connect");
63c038c2
JL		 1808 /* BB should we allow ipv6 on port 139? */
1809 /* other OS never observed in Wild doing 139 with v6 */
a9f1b85e
PS		 1810 memcpy(&tcp_ses->dstaddr, sin_server6,
1811 sizeof(struct sockaddr_in6));
1812 } else
1813 memcpy(&tcp_ses->dstaddr, sin_server,
1814 sizeof(struct sockaddr_in));
1815
1816 rc = ip_connect(tcp_ses);
63c038c2 1817 if (rc < 0) {
b6b38f70 1818 cERROR(1, "Error connecting to socket. Aborting operation");
f7c5445a 1819 goto out_err_crypto_release;
63c038c2
JL		 1820 }
1821
1822 /*
1823 * since we're in a cifs function already, we know that
1824 * this will succeed. No need for try_module_get().
1825 */
1826 __module_get(THIS_MODULE);
1827 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1828 tcp_ses, "cifsd");
1829 if (IS_ERR(tcp_ses->tsk)) {
1830 rc = PTR_ERR(tcp_ses->tsk);
b6b38f70 1831 cERROR(1, "error %d create cifsd thread", rc);
63c038c2 1832 module_put(THIS_MODULE);
f7c5445a 1833 goto out_err_crypto_release;
63c038c2 1834 }
fd88ce93 1835 tcp_ses->tcpStatus = CifsNeedNegotiate;
63c038c2
JL		 1836
1837 /* thread spawned, put it on the list */
3f9bcca7 1838 spin_lock(&cifs_tcp_ses_lock);
63c038c2 1839 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
3f9bcca7 1840 spin_unlock(&cifs_tcp_ses_lock);
63c038c2 1841
488f1d2d
SJ		 1842 cifs_fscache_get_client_cookie(tcp_ses);
1843
c74093b6
JL		 1844 /* queue echo request delayed work */
1845 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1846
63c038c2
JL		 1847 return tcp_ses;
1848
f7c5445a 1849out_err_crypto_release:
d2b91521
SP		 1850 cifs_crypto_shash_release(tcp_ses);
1851
f1d0c998
RL		 1852 put_net(cifs_net_ns(tcp_ses));
1853
63c038c2
JL		 1854out_err:
1855 if (tcp_ses) {
8347a5cd
SF		 1856 if (!IS_ERR(tcp_ses->hostname))
1857 kfree(tcp_ses->hostname);
63c038c2
JL		 1858 if (tcp_ses->ssocket)
1859 sock_release(tcp_ses->ssocket);
1860 kfree(tcp_ses);
1861 }
1862 return ERR_PTR(rc);
1863}
1864
37bb04e5
PS		 1865static int match_session(struct cifsSesInfo *ses, struct smb_vol *vol)
1866{
1867 switch (ses->server->secType) {
1868 case Kerberos:
1869 if (vol->cred_uid != ses->cred_uid)
1870 return 0;
1871 break;
1872 default:
1873 /* anything else takes username/password */
1874 if (ses->user_name == NULL)
1875 return 0;
1876 if (strncmp(ses->user_name, vol->username,
1877 MAX_USERNAME_SIZE))
1878 return 0;
1879 if (strlen(vol->username) != 0 &&
1880 ses->password != NULL &&
1881 strncmp(ses->password,
1882 vol->password ? vol->password : "",
1883 MAX_PASSWORD_SIZE))
1884 return 0;
1885 }
1886 return 1;
1887}
1888
14fbf50d 1889static struct cifsSesInfo *
4ff67b72 1890cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1da177e4 1891{
14fbf50d 1892 struct cifsSesInfo *ses;
dea570e0 1893
3f9bcca7 1894 spin_lock(&cifs_tcp_ses_lock);
4ff67b72 1895 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
37bb04e5
PS		 1896 if (!match_session(ses, vol))
1897 continue;
14fbf50d 1898 ++ses->ses_count;
3f9bcca7 1899 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 1900 return ses;
1901 }
3f9bcca7 1902 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 1903 return NULL;
1904}
dea570e0 1905
14fbf50d
JL		 1906static void
1907cifs_put_smb_ses(struct cifsSesInfo *ses)
1908{
1909 int xid;
1910 struct TCP_Server_Info *server = ses->server;
dea570e0 1911
36988c76 1912 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
3f9bcca7 1913 spin_lock(&cifs_tcp_ses_lock);
14fbf50d 1914 if (--ses->ses_count > 0) {
3f9bcca7 1915 spin_unlock(&cifs_tcp_ses_lock);
14fbf50d
JL		 1916 return;
1917 }
dea570e0 1918
14fbf50d 1919 list_del_init(&ses->smb_ses_list);
3f9bcca7 1920 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 1921
14fbf50d
JL		 1922 if (ses->status == CifsGood) {
1923 xid = GetXid();
1924 CIFSSMBLogoff(xid, ses);
1925 _FreeXid(xid);
1926 }
1927 sesInfoFree(ses);
1928 cifs_put_tcp_session(server);
1929}
dea570e0 1930
d9b94201
SF		 1931static bool warned_on_ntlm; /* globals init to false automatically */
1932
36988c76
JL		 1933static struct cifsSesInfo *
1934cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1935{
1936 int rc = -ENOMEM, xid;
1937 struct cifsSesInfo *ses;
a9f1b85e
PS		 1938 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1939 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
36988c76
JL		 1940
1941 xid = GetXid();
1942
4ff67b72 1943 ses = cifs_find_smb_ses(server, volume_info);
36988c76
JL		 1944 if (ses) {
1945 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1946
36988c76 1947 mutex_lock(&ses->session_mutex);
198b5682
JL		 1948 rc = cifs_negotiate_protocol(xid, ses);
1949 if (rc) {
1950 mutex_unlock(&ses->session_mutex);
1951 /* problem -- put our ses reference */
1952 cifs_put_smb_ses(ses);
1953 FreeXid(xid);
1954 return ERR_PTR(rc);
1955 }
36988c76
JL		 1956 if (ses->need_reconnect) {
1957 cFYI(1, "Session needs reconnect");
1958 rc = cifs_setup_session(xid, ses,
1959 volume_info->local_nls);
1960 if (rc) {
1961 mutex_unlock(&ses->session_mutex);
1962 /* problem -- put our reference */
1963 cifs_put_smb_ses(ses);
1964 FreeXid(xid);
1965 return ERR_PTR(rc);
1966 }
1967 }
1968 mutex_unlock(&ses->session_mutex);
460cf341
JL		 1969
1970 /* existing SMB ses has a server reference already */
1971 cifs_put_tcp_session(server);
36988c76
JL		 1972 FreeXid(xid);
1973 return ses;
1974 }
1975
1976 cFYI(1, "Existing smb sess not found");
1977 ses = sesInfoAlloc();
1978 if (ses == NULL)
1979 goto get_ses_fail;
1980
1981 /* new SMB session uses our server ref */
1982 ses->server = server;
a9f1b85e
PS		 1983 if (server->dstaddr.ss_family == AF_INET6)
1984 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
36988c76 1985 else
a9f1b85e 1986 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
36988c76 1987
8727c8a8
SF		 1988 if (volume_info->username) {
1989 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1990 if (!ses->user_name)
1991 goto get_ses_fail;
1992 }
36988c76
JL		 1993
1994 /* volume_info->password freed at unmount */
1995 if (volume_info->password) {
1996 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1997 if (!ses->password)
1998 goto get_ses_fail;
1999 }
2000 if (volume_info->domainname) {
d3686d54
SP		 2001 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2002 if (!ses->domainName)
2003 goto get_ses_fail;
36988c76 2004 }
3e4b3e1f 2005 ses->cred_uid = volume_info->cred_uid;
36988c76 2006 ses->linux_uid = volume_info->linux_uid;
d9b94201
SF		 2007
2008 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2009 supported for many years, time to update default security mechanism */
2010 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2011 warned_on_ntlm = true;
2012 cERROR(1, "default security mechanism requested. The default "
2013 "security mechanism will be upgraded from ntlm to "
2014 "ntlmv2 in kernel release 2.6.41");
2015 }
36988c76
JL		 2016 ses->overrideSecFlg = volume_info->secFlg;
2017
2018 mutex_lock(&ses->session_mutex);
198b5682
JL		 2019 rc = cifs_negotiate_protocol(xid, ses);
2020 if (!rc)
2021 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
36988c76 2022 mutex_unlock(&ses->session_mutex);
c8e56f1f 2023 if (rc)
36988c76
JL		 2024 goto get_ses_fail;
2025
2026 /* success, put it on the list */
3f9bcca7 2027 spin_lock(&cifs_tcp_ses_lock);
36988c76 2028 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3f9bcca7 2029 spin_unlock(&cifs_tcp_ses_lock);
36988c76
JL		 2030
2031 FreeXid(xid);
2032 return ses;
2033
2034get_ses_fail:
2035 sesInfoFree(ses);
2036 FreeXid(xid);
2037 return ERR_PTR(rc);
2038}
2039
37bb04e5
PS		 2040static int match_tcon(struct cifsTconInfo *tcon, const char *unc)
2041{
2042 if (tcon->tidStatus == CifsExiting)
2043 return 0;
2044 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2045 return 0;
2046 return 1;
2047}
2048
f1987b44
JL		 2049static struct cifsTconInfo *
2050cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
2051{
2052 struct list_head *tmp;
2053 struct cifsTconInfo *tcon;
2054
3f9bcca7 2055 spin_lock(&cifs_tcp_ses_lock);
f1987b44
JL		 2056 list_for_each(tmp, &ses->tcon_list) {
2057 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
37bb04e5 2058 if (!match_tcon(tcon, unc))
f1987b44 2059 continue;
f1987b44 2060 ++tcon->tc_count;
3f9bcca7 2061 spin_unlock(&cifs_tcp_ses_lock);
dea570e0 2062 return tcon;
1da177e4 2063 }
3f9bcca7 2064 spin_unlock(&cifs_tcp_ses_lock);
1da177e4
LT		 2065 return NULL;
2066}
2067
f1987b44
JL		 2068static void
2069cifs_put_tcon(struct cifsTconInfo *tcon)
2070{
2071 int xid;
2072 struct cifsSesInfo *ses = tcon->ses;
2073
d00c28de 2074 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3f9bcca7 2075 spin_lock(&cifs_tcp_ses_lock);
f1987b44 2076 if (--tcon->tc_count > 0) {
3f9bcca7 2077 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2078 return;
2079 }
2080
2081 list_del_init(&tcon->tcon_list);
3f9bcca7 2082 spin_unlock(&cifs_tcp_ses_lock);
f1987b44
JL		 2083
2084 xid = GetXid();
2085 CIFSSMBTDis(xid, tcon);
2086 _FreeXid(xid);
2087
d03382ce 2088 cifs_fscache_release_super_cookie(tcon);
9f841593 2089 tconInfoFree(tcon);
f1987b44
JL		 2090 cifs_put_smb_ses(ses);
2091}
2092
d00c28de
JL		 2093static struct cifsTconInfo *
2094cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2095{
2096 int rc, xid;
2097 struct cifsTconInfo *tcon;
2098
2099 tcon = cifs_find_tcon(ses, volume_info->UNC);
2100 if (tcon) {
2101 cFYI(1, "Found match on UNC path");
2102 /* existing tcon already has a reference */
2103 cifs_put_smb_ses(ses);
2104 if (tcon->seal != volume_info->seal)
2105 cERROR(1, "transport encryption setting "
2106 "conflicts with existing tid");
2107 return tcon;
2108 }
2109
2110 tcon = tconInfoAlloc();
2111 if (tcon == NULL) {
2112 rc = -ENOMEM;
2113 goto out_fail;
2114 }
2115
2116 tcon->ses = ses;
2117 if (volume_info->password) {
2118 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2119 if (!tcon->password) {
2120 rc = -ENOMEM;
2121 goto out_fail;
2122 }
2123 }
2124
2125 if (strchr(volume_info->UNC + 3, '\\') == NULL
2126 && strchr(volume_info->UNC + 3, '/') == NULL) {
2127 cERROR(1, "Missing share name");
2128 rc = -ENODEV;
2129 goto out_fail;
2130 }
2131
2132 /* BB Do we need to wrap session_mutex around
2133 * this TCon call and Unix SetFS as
2134 * we do on SessSetup and reconnect? */
2135 xid = GetXid();
2136 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2137 FreeXid(xid);
2138 cFYI(1, "CIFS Tcon rc = %d", rc);
2139 if (rc)
2140 goto out_fail;
2141
2142 if (volume_info->nodfs) {
2143 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2144 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2145 }
2146 tcon->seal = volume_info->seal;
2147 /* we can have only one retry value for a connection
2148 to a share so for resources mounted more than once
2149 to the same server share the last value passed in
2150 for the retry flag is used */
2151 tcon->retry = volume_info->retry;
2152 tcon->nocase = volume_info->nocase;
2153 tcon->local_lease = volume_info->local_lease;
2154
3f9bcca7 2155 spin_lock(&cifs_tcp_ses_lock);
d00c28de 2156 list_add(&tcon->tcon_list, &ses->tcon_list);
3f9bcca7 2157 spin_unlock(&cifs_tcp_ses_lock);
d00c28de 2158
d03382ce
SJ		 2159 cifs_fscache_get_super_cookie(tcon);
2160
d00c28de
JL		 2161 return tcon;
2162
2163out_fail:
2164 tconInfoFree(tcon);
2165 return ERR_PTR(rc);
2166}
2167
9d002df4
JL		 2168void
2169cifs_put_tlink(struct tcon_link *tlink)
2170{
2171 if (!tlink || IS_ERR(tlink))
2172 return;
2173
2174 if (!atomic_dec_and_test(&tlink->tl_count) ||
2175 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2176 tlink->tl_time = jiffies;
2177 return;
2178 }
2179
2180 if (!IS_ERR(tlink_tcon(tlink)))
2181 cifs_put_tcon(tlink_tcon(tlink));
2182 kfree(tlink);
2183 return;
2184}
d00c28de 2185
1da177e4 2186int
50c2f753
SF		 2187get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2188 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
366781c1 2189 struct dfs_info3_param **preferrals, int remap)
1da177e4
LT		 2190{
2191 char *temp_unc;
2192 int rc = 0;
2193
2194 *pnum_referrals = 0;
366781c1 2195 *preferrals = NULL;
1da177e4
LT		 2196
2197 if (pSesInfo->ipc_tid == 0) {
2198 temp_unc = kmalloc(2 /* for slashes */ +
50c2f753
SF		 2199 strnlen(pSesInfo->serverName,
2200 SERVER_NAME_LEN_WITH_NULL * 2)
1da177e4
LT		 2201 + 1 + 4 /* slash IPC$ */ + 2,
2202 GFP_KERNEL);
2203 if (temp_unc == NULL)
2204 return -ENOMEM;
2205 temp_unc[0] = '\\';
2206 temp_unc[1] = '\\';
2207 strcpy(temp_unc + 2, pSesInfo->serverName);
2208 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2209 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
b6b38f70 2210 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
1da177e4
LT		 2211 kfree(temp_unc);
2212 }
2213 if (rc == 0)
c2cf07d5 2214 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
737b758c 2215 pnum_referrals, nls_codepage, remap);
366781c1
SF		 2216 /* BB map targetUNCs to dfs_info3 structures, here or
2217 in CIFSGetDFSRefer BB */
1da177e4
LT		 2218
2219 return rc;
2220}
2221
09e50d55
JL		 2222#ifdef CONFIG_DEBUG_LOCK_ALLOC
2223static struct lock_class_key cifs_key[2];
2224static struct lock_class_key cifs_slock_key[2];
2225
2226static inline void
2227cifs_reclassify_socket4(struct socket *sock)
2228{
2229 struct sock *sk = sock->sk;
2230 BUG_ON(sock_owned_by_user(sk));
2231 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2232 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2233}
2234
2235static inline void
2236cifs_reclassify_socket6(struct socket *sock)
2237{
2238 struct sock *sk = sock->sk;
2239 BUG_ON(sock_owned_by_user(sk));
2240 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2241 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2242}
2243#else
2244static inline void
2245cifs_reclassify_socket4(struct socket *sock)
2246{
2247}
2248
2249static inline void
2250cifs_reclassify_socket6(struct socket *sock)
2251{
2252}
2253#endif
2254
1da177e4 2255/* See RFC1001 section 14 on representation of Netbios names */
50c2f753 2256static void rfc1002mangle(char *target, char *source, unsigned int length)
1da177e4 2257{
50c2f753 2258 unsigned int i, j;
1da177e4 2259
50c2f753 2260 for (i = 0, j = 0; i < (length); i++) {
1da177e4
LT		 2261 /* mask a nibble at a time and encode */
2262 target[j] = 'A' + (0x0F & (source[i] >> 4));
2263 target[j+1] = 'A' + (0x0F & source[i]);
50c2f753 2264 j += 2;
1da177e4
LT		 2265 }
2266
2267}
2268
3eb9a889
BG		 2269static int
2270bind_socket(struct TCP_Server_Info *server)
2271{
2272 int rc = 0;
2273 if (server->srcaddr.ss_family != AF_UNSPEC) {
2274 /* Bind to the specified local IP address */
2275 struct socket *socket = server->ssocket;
2276 rc = socket->ops->bind(socket,
2277 (struct sockaddr *) &server->srcaddr,
2278 sizeof(server->srcaddr));
2279 if (rc < 0) {
2280 struct sockaddr_in *saddr4;
2281 struct sockaddr_in6 *saddr6;
2282 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2283 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2284 if (saddr6->sin6_family == AF_INET6)
2285 cERROR(1, "cifs: "
2286 "Failed to bind to: %pI6c, error: %d\n",
2287 &saddr6->sin6_addr, rc);
2288 else
2289 cERROR(1, "cifs: "
2290 "Failed to bind to: %pI4, error: %d\n",
2291 &saddr4->sin_addr.s_addr, rc);
2292 }
2293 }
2294 return rc;
2295}
1da177e4
LT		 2296
2297static int
a9f1b85e 2298ip_rfc1001_connect(struct TCP_Server_Info *server)
1da177e4
LT		 2299{
2300 int rc = 0;
a9f1b85e
PS		 2301 /*
2302 * some servers require RFC1001 sessinit before sending
2303 * negprot - BB check reconnection in case where second
2304 * sessinit is sent but no second negprot
2305 */
2306 struct rfc1002_session_packet *ses_init_buf;
2307 struct smb_hdr *smb_buf;
2308 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2309 GFP_KERNEL);
2310 if (ses_init_buf) {
2311 ses_init_buf->trailer.session_req.called_len = 32;
2312
2313 if (server->server_RFC1001_name &&
2314 server->server_RFC1001_name[0] != 0)
2315 rfc1002mangle(ses_init_buf->trailer.
2316 session_req.called_name,
2317 server->server_RFC1001_name,
2318 RFC1001_NAME_LEN_WITH_NULL);
2319 else
2320 rfc1002mangle(ses_init_buf->trailer.
2321 session_req.called_name,
2322 DEFAULT_CIFS_CALLED_NAME,
2323 RFC1001_NAME_LEN_WITH_NULL);
2324
2325 ses_init_buf->trailer.session_req.calling_len = 32;
2326
2327 /*
2328 * calling name ends in null (byte 16) from old smb
2329 * convention.
2330 */
2331 if (server->workstation_RFC1001_name &&
2332 server->workstation_RFC1001_name[0] != 0)
2333 rfc1002mangle(ses_init_buf->trailer.
2334 session_req.calling_name,
2335 server->workstation_RFC1001_name,
2336 RFC1001_NAME_LEN_WITH_NULL);
2337 else
2338 rfc1002mangle(ses_init_buf->trailer.
2339 session_req.calling_name,
2340 "LINUX_CIFS_CLNT",
2341 RFC1001_NAME_LEN_WITH_NULL);
2342
2343 ses_init_buf->trailer.session_req.scope1 = 0;
2344 ses_init_buf->trailer.session_req.scope2 = 0;
2345 smb_buf = (struct smb_hdr *)ses_init_buf;
2346
2347 /* sizeof RFC1002_SESSION_REQUEST with no scope */
be8e3b00 2348 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
a9f1b85e
PS		 2349 rc = smb_send(server, smb_buf, 0x44);
2350 kfree(ses_init_buf);
2351 /*
2352 * RFC1001 layer in at least one server
2353 * requires very short break before negprot
2354 * presumably because not expecting negprot
2355 * to follow so fast. This is a simple
2356 * solution that works without
2357 * complicating the code and causes no
2358 * significant slowing down on mount
2359 * for everyone else
2360 */
2361 usleep_range(1000, 2000);
2362 }
2363 /*
2364 * else the negprot may still work without this
2365 * even though malloc failed
2366 */
2367
2368 return rc;
2369}
2370
2371static int
2372generic_ip_connect(struct TCP_Server_Info *server)
2373{
2374 int rc = 0;
6da97910 2375 __be16 sport;
a9f1b85e 2376 int slen, sfamily;
bcf4b106 2377 struct socket *socket = server->ssocket;
a9f1b85e
PS		 2378 struct sockaddr *saddr;
2379
2380 saddr = (struct sockaddr *) &server->dstaddr;
2381
2382 if (server->dstaddr.ss_family == AF_INET6) {
2383 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2384 slen = sizeof(struct sockaddr_in6);
2385 sfamily = AF_INET6;
2386 } else {
2387 sport = ((struct sockaddr_in *) saddr)->sin_port;
2388 slen = sizeof(struct sockaddr_in);
2389 sfamily = AF_INET;
2390 }
1da177e4 2391
bcf4b106 2392 if (socket == NULL) {
f1d0c998
RL		 2393 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2394 IPPROTO_TCP, &socket, 1);
1da177e4 2395 if (rc < 0) {
b6b38f70 2396 cERROR(1, "Error %d creating socket", rc);
a9f1b85e 2397 server->ssocket = NULL;
1da177e4 2398 return rc;
1da177e4 2399 }
bcf4b106
JL		 2400
2401 /* BB other socket options to set KEEPALIVE, NODELAY? */
b6b38f70 2402 cFYI(1, "Socket created");
bcf4b106
JL		 2403 server->ssocket = socket;
2404 socket->sk->sk_allocation = GFP_NOFS;
a9f1b85e
PS		 2405 if (sfamily == AF_INET6)
2406 cifs_reclassify_socket6(socket);
2407 else
2408 cifs_reclassify_socket4(socket);
1da177e4
LT		 2409 }
2410
3eb9a889
BG		 2411 rc = bind_socket(server);
2412 if (rc < 0)
2413 return rc;
2414
a9f1b85e
PS		 2415 rc = socket->ops->connect(socket, saddr, slen, 0);
2416 if (rc < 0) {
2417 cFYI(1, "Error %d connecting to server", rc);
bcf4b106
JL		 2418 sock_release(socket);
2419 server->ssocket = NULL;
1da177e4
LT		 2420 return rc;
2421 }
bcf4b106 2422
bcf4b106
JL		 2423 /*
2424 * Eventually check for other socket options to change from
a9f1b85e
PS		 2425 * the default. sock_setsockopt not used because it expects
2426 * user space buffer
bcf4b106
JL		 2427 */
2428 socket->sk->sk_rcvtimeo = 7 * HZ;
da505c38 2429 socket->sk->sk_sndtimeo = 5 * HZ;
edf1ae40 2430
b387eaeb 2431 /* make the bufsizes depend on wsize/rsize and max requests */
bcf4b106
JL		 2432 if (server->noautotune) {
2433 if (socket->sk->sk_sndbuf < (200 * 1024))
2434 socket->sk->sk_sndbuf = 200 * 1024;
2435 if (socket->sk->sk_rcvbuf < (140 * 1024))
2436 socket->sk->sk_rcvbuf = 140 * 1024;
edf1ae40 2437 }
1da177e4 2438
6a5fa236 2439 if (server->tcp_nodelay) {
a9f1b85e 2440 int val = 1;
6a5fa236
SF		 2441 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2442 (char *)&val, sizeof(val));
2443 if (rc)
b6b38f70 2444 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
6a5fa236
SF		 2445 }
2446
b6b38f70 2447 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
bcf4b106 2448 socket->sk->sk_sndbuf,
b6b38f70 2449 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
bcf4b106 2450
a9f1b85e
PS		 2451 if (sport == htons(RFC1001_PORT))
2452 rc = ip_rfc1001_connect(server);
50c2f753 2453
1da177e4
LT		 2454 return rc;
2455}
2456
2457static int
a9f1b85e 2458ip_connect(struct TCP_Server_Info *server)
1da177e4 2459{
6da97910 2460 __be16 *sport;
a9f1b85e
PS		 2461 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2462 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1da177e4 2463
a9f1b85e
PS		 2464 if (server->dstaddr.ss_family == AF_INET6)
2465 sport = &addr6->sin6_port;
2466 else
2467 sport = &addr->sin_port;
1da177e4 2468
a9f1b85e
PS		 2469 if (*sport == 0) {
2470 int rc;
1da177e4 2471
a9f1b85e
PS		 2472 /* try with 445 port at first */
2473 *sport = htons(CIFS_PORT);
3eb9a889 2474
a9f1b85e 2475 rc = generic_ip_connect(server);
1da177e4 2476 if (rc >= 0)
a9f1b85e 2477 return rc;
6a5fa236 2478
a9f1b85e
PS		 2479 /* if it failed, try with 139 port */
2480 *sport = htons(RFC1001_PORT);
6a5fa236
SF		 2481 }
2482
a9f1b85e 2483 return generic_ip_connect(server);
1da177e4
LT		 2484}
2485
50c2f753
SF		 2486void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2487 struct super_block *sb, struct smb_vol *vol_info)
8af18971
SF		 2488{
2489 /* if we are reconnecting then should we check to see if
2490 * any requested capabilities changed locally e.g. via
2491 * remount but we can not do much about it here
2492 * if they have (even if we could detect it by the following)
2493 * Perhaps we could add a backpointer to array of sb from tcon
2494 * or if we change to make all sb to same share the same
2495 * sb as NFS - then we only have one backpointer to sb.
2496 * What if we wanted to mount the server share twice once with
2497 * and once without posixacls or posix paths? */
2498 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 2499
c18c842b
SF		 2500 if (vol_info && vol_info->no_linux_ext) {
2501 tcon->fsUnixInfo.Capability = 0;
2502 tcon->unix_ext = 0; /* Unix Extensions disabled */
b6b38f70 2503 cFYI(1, "Linux protocol extensions disabled");
c18c842b
SF		 2504 return;
2505 } else if (vol_info)
2506 tcon->unix_ext = 1; /* Unix Extensions supported */
2507
2508 if (tcon->unix_ext == 0) {
b6b38f70 2509 cFYI(1, "Unix extensions disabled so not set on reconnect");
c18c842b
SF		 2510 return;
2511 }
50c2f753 2512
fb8c4b14 2513 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
8af18971 2514 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
50c2f753 2515
8af18971
SF		 2516 /* check for reconnect case in which we do not
2517 want to change the mount behavior if we can avoid it */
fb8c4b14 2518 if (vol_info == NULL) {
50c2f753 2519 /* turn off POSIX ACL and PATHNAMES if not set
8af18971
SF		 2520 originally at mount time */
2521 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2522 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
11b6d645
IM		 2523 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2524 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 2525 cERROR(1, "POSIXPATH support change");
8af18971 2526 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
11b6d645 2527 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
b6b38f70
JP		 2528 cERROR(1, "possible reconnect error");
2529 cERROR(1, "server disabled POSIX path support");
11b6d645 2530 }
8af18971 2531 }
50c2f753 2532
8af18971 2533 cap &= CIFS_UNIX_CAP_MASK;
75865f8c 2534 if (vol_info && vol_info->no_psx_acl)
8af18971 2535 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
75865f8c 2536 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
b6b38f70 2537 cFYI(1, "negotiated posix acl support");
fb8c4b14 2538 if (sb)
8af18971
SF		 2539 sb->s_flags |= MS_POSIXACL;
2540 }
2541
75865f8c 2542 if (vol_info && vol_info->posix_paths == 0)
8af18971 2543 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
75865f8c 2544 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
b6b38f70 2545 cFYI(1, "negotiate posix pathnames");
75865f8c 2546 if (sb)
50c2f753 2547 CIFS_SB(sb)->mnt_cifs_flags |=
8af18971
SF		 2548 CIFS_MOUNT_POSIX_PATHS;
2549 }
50c2f753 2550
984acfe1
SF		 2551 /* We might be setting the path sep back to a different
2552 form if we are reconnecting and the server switched its
50c2f753 2553 posix path capability for this share */
75865f8c 2554 if (sb && (CIFS_SB(sb)->prepathlen > 0))
984acfe1 2555 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
75865f8c
SF		 2556
2557 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2558 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2559 CIFS_SB(sb)->rsize = 127 * 1024;
b6b38f70 2560 cFYI(DBG2, "larger reads not supported by srv");
75865f8c
SF		 2561 }
2562 }
50c2f753
SF		 2563
2564
b6b38f70 2565 cFYI(1, "Negotiate caps 0x%x", (int)cap);
8af18971 2566#ifdef CONFIG_CIFS_DEBUG2
75865f8c 2567 if (cap & CIFS_UNIX_FCNTL_CAP)
b6b38f70 2568 cFYI(1, "FCNTL cap");
75865f8c 2569 if (cap & CIFS_UNIX_EXTATTR_CAP)
b6b38f70 2570 cFYI(1, "EXTATTR cap");
75865f8c 2571 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
b6b38f70 2572 cFYI(1, "POSIX path cap");
75865f8c 2573 if (cap & CIFS_UNIX_XATTR_CAP)
b6b38f70 2574 cFYI(1, "XATTR cap");
75865f8c 2575 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
b6b38f70 2576 cFYI(1, "POSIX ACL cap");
75865f8c 2577 if (cap & CIFS_UNIX_LARGE_READ_CAP)
b6b38f70 2578 cFYI(1, "very large read cap");
75865f8c 2579 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
b6b38f70 2580 cFYI(1, "very large write cap");
8af18971
SF		 2581#endif /* CIFS_DEBUG2 */
2582 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
442aa310 2583 if (vol_info == NULL) {
b6b38f70 2584 cFYI(1, "resetting capabilities failed");
442aa310 2585 } else
b6b38f70 2586 cERROR(1, "Negotiating Unix capabilities "
5a44b319
SF		 2587 "with the server failed. Consider "
2588 "mounting with the Unix Extensions\n"
2589 "disabled, if problems are found, "
2590 "by specifying the nounix mount "
b6b38f70 2591 "option.");
5a44b319 2592
8af18971
SF		 2593 }
2594 }
2595}
2596
03a143c9
SF		 2597static void
2598convert_delimiter(char *path, char delim)
2599{
2600 int i;
c2d68ea6 2601 char old_delim;
03a143c9
SF		 2602
2603 if (path == NULL)
2604 return;
2605
582d21e5 2606 if (delim == '/')
c2d68ea6
SF		 2607 old_delim = '\\';
2608 else
2609 old_delim = '/';
2610
03a143c9 2611 for (i = 0; path[i] != '\0'; i++) {
c2d68ea6 2612 if (path[i] == old_delim)
03a143c9
SF		 2613 path[i] = delim;
2614 }
2615}
2616
3b795210
SF		 2617static void setup_cifs_sb(struct smb_vol *pvolume_info,
2618 struct cifs_sb_info *cifs_sb)
b1c8d2b4 2619{
2de970ff
JL		 2620 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2621
3b795210 2622 if (pvolume_info->rsize > CIFSMaxBufSize) {
b6b38f70
JP		 2623 cERROR(1, "rsize %d too large, using MaxBufSize",
2624 pvolume_info->rsize);
3b795210
SF		 2625 cifs_sb->rsize = CIFSMaxBufSize;
2626 } else if ((pvolume_info->rsize) &&
2627 (pvolume_info->rsize <= CIFSMaxBufSize))
2628 cifs_sb->rsize = pvolume_info->rsize;
2629 else /* default */
2630 cifs_sb->rsize = CIFSMaxBufSize;
2631
2632 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
b6b38f70
JP		 2633 cERROR(1, "wsize %d too large, using 4096 instead",
2634 pvolume_info->wsize);
3b795210
SF		 2635 cifs_sb->wsize = 4096;
2636 } else if (pvolume_info->wsize)
2637 cifs_sb->wsize = pvolume_info->wsize;
2638 else
2639 cifs_sb->wsize = min_t(const int,
2640 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2641 127*1024);
2642 /* old default of CIFSMaxBufSize was too small now
2643 that SMB Write2 can send multiple pages in kvec.
2644 RFC1001 does not describe what happens when frame
2645 bigger than 128K is sent so use that as max in
2646 conjunction with 52K kvec constraint on arch with 4K
2647 page size */
2648
2649 if (cifs_sb->rsize < 2048) {
2650 cifs_sb->rsize = 2048;
2651 /* Windows ME may prefer this */
b6b38f70 2652 cFYI(1, "readsize set to minimum: 2048");
3b795210
SF		 2653 }
2654 /* calculate prepath */
2655 cifs_sb->prepath = pvolume_info->prepath;
2656 if (cifs_sb->prepath) {
2657 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2658 /* we can not convert the / to \ in the path
2659 separators in the prefixpath yet because we do not
2660 know (until reset_cifs_unix_caps is called later)
2661 whether POSIX PATH CAP is available. We normalize
2662 the / to \ after reset_cifs_unix_caps is called */
2663 pvolume_info->prepath = NULL;
2664 } else
2665 cifs_sb->prepathlen = 0;
2666 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2667 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2668 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2669 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
b6b38f70
JP		 2670 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2671 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3b795210 2672
6d20e840
SJ		 2673 cifs_sb->actimeo = pvolume_info->actimeo;
2674
3b795210
SF		 2675 if (pvolume_info->noperm)
2676 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2677 if (pvolume_info->setuids)
2678 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2679 if (pvolume_info->server_ino)
2680 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2681 if (pvolume_info->remap)
2682 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2683 if (pvolume_info->no_xattr)
2684 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2685 if (pvolume_info->sfu_emul)
2686 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2687 if (pvolume_info->nobrl)
2688 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
be652445 2689 if (pvolume_info->nostrictsync)
4717bed6 2690 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
13a6e42a
SF		 2691 if (pvolume_info->mand_lock)
2692 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3b795210
SF		 2693 if (pvolume_info->cifs_acl)
2694 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2695 if (pvolume_info->override_uid)
2696 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2697 if (pvolume_info->override_gid)
2698 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2699 if (pvolume_info->dynperm)
2700 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
fa1df75d
SJ		 2701 if (pvolume_info->fsc)
2702 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
0eb8a132
JL		 2703 if (pvolume_info->multiuser)
2704 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2705 CIFS_MOUNT_NO_PERM);
d39454ff
PS		 2706 if (pvolume_info->strict_io)
2707 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3b795210 2708 if (pvolume_info->direct_io) {
b6b38f70 2709 cFYI(1, "mounting share using direct i/o");
3b795210
SF		 2710 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2711 }
736a3320
SM		 2712 if (pvolume_info->mfsymlinks) {
2713 if (pvolume_info->sfu_emul) {
2714 cERROR(1, "mount option mfsymlinks ignored if sfu "
2715 "mount option is used");
2716 } else {
2717 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2718 }
2719 }
3b795210
SF		 2720
2721 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
b6b38f70
JP		 2722 cERROR(1, "mount option dynperm ignored if cifsacl "
2723 "mount option supported");
b1c8d2b4
JL		 2724}
2725
e4cce94c
IM		 2726static int
2727is_path_accessible(int xid, struct cifsTconInfo *tcon,
2728 struct cifs_sb_info *cifs_sb, const char *full_path)
2729{
2730 int rc;
e4cce94c
IM		 2731 FILE_ALL_INFO *pfile_info;
2732
e4cce94c
IM		 2733 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2734 if (pfile_info == NULL)
2735 return -ENOMEM;
2736
2737 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2738 0 /* not legacy */, cifs_sb->local_nls,
2739 cifs_sb->mnt_cifs_flags &
2740 CIFS_MOUNT_MAP_SPECIAL_CHR);
221d1d79
JL		 2741
2742 if (rc == -EOPNOTSUPP || rc == -EINVAL)
2743 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
2744 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
2745 CIFS_MOUNT_MAP_SPECIAL_CHR);
e4cce94c
IM		 2746 kfree(pfile_info);
2747 return rc;
2748}
2749
1bfe73c2
IM		 2750static void
2751cleanup_volume_info(struct smb_vol **pvolume_info)
2752{
2753 struct smb_vol *volume_info;
2754
ad6cca6d 2755 if (!pvolume_info || !*pvolume_info)
1bfe73c2
IM		 2756 return;
2757
2758 volume_info = *pvolume_info;
b946845a 2759 kfree(volume_info->username);
1bfe73c2
IM		 2760 kzfree(volume_info->password);
2761 kfree(volume_info->UNC);
b946845a
SF		 2762 kfree(volume_info->UNCip);
2763 kfree(volume_info->domainname);
2764 kfree(volume_info->iocharset);
1bfe73c2
IM		 2765 kfree(volume_info->prepath);
2766 kfree(volume_info);
2767 *pvolume_info = NULL;
2768 return;
2769}
2770
2d6d589d 2771#ifdef CONFIG_CIFS_DFS_UPCALL
1bfe73c2
IM		 2772/* build_path_to_root returns full path to root when
2773 * we do not have an exiting connection (tcon) */
2774static char *
2775build_unc_path_to_root(const struct smb_vol *volume_info,
2776 const struct cifs_sb_info *cifs_sb)
2777{
2778 char *full_path;
2779
2780 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2781 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2782 if (full_path == NULL)
2783 return ERR_PTR(-ENOMEM);
2784
2785 strncpy(full_path, volume_info->UNC, unc_len);
2786 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2787 int i;
2788 for (i = 0; i < unc_len; i++) {
2789 if (full_path[i] == '\\')
2790 full_path[i] = '/';
2791 }
2792 }
2793
2794 if (cifs_sb->prepathlen)
2795 strncpy(full_path + unc_len, cifs_sb->prepath,
2796 cifs_sb->prepathlen);
2797
2798 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2799 return full_path;
2800}
dd613945
SF		 2801
2802/*
2803 * Perform a dfs referral query for a share and (optionally) prefix
2804 *
046462ab
SF		 2805 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
2806 * to a string containing updated options for the submount. Otherwise it
2807 * will be left untouched.
dd613945
SF		 2808 *
2809 * Returns the rc from get_dfs_path to the caller, which can be used to
2810 * determine whether there were referrals.
2811 */
2812static int
2813expand_dfs_referral(int xid, struct cifsSesInfo *pSesInfo,
2814 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
046462ab 2815 int check_prefix)
dd613945
SF		 2816{
2817 int rc;
2818 unsigned int num_referrals = 0;
2819 struct dfs_info3_param *referrals = NULL;
2820 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
2821
2822 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2823 if (IS_ERR(full_path))
2824 return PTR_ERR(full_path);
2825
2826 /* For DFS paths, skip the first '\' of the UNC */
2827 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
2828
2829 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
2830 &num_referrals, &referrals,
2831 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2832
2833 if (!rc && num_referrals > 0) {
2834 char *fake_devname = NULL;
2835
2836 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
2837 full_path + 1, referrals,
2838 &fake_devname);
2839
2840 free_dfs_info_array(referrals, num_referrals);
2841 kfree(fake_devname);
2842
046462ab
SF		 2843 if (cifs_sb->mountdata != NULL)
2844 kfree(cifs_sb->mountdata);
2845
dd613945
SF		 2846 if (IS_ERR(mdata)) {
2847 rc = PTR_ERR(mdata);
2848 mdata = NULL;
2849 }
046462ab 2850 cifs_sb->mountdata = mdata;
dd613945
SF		 2851 }
2852 kfree(full_path);
2853 return rc;
2854}
2d6d589d 2855#endif
1bfe73c2 2856
1da177e4
LT		 2857int
2858cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
f14bcf71 2859 const char *devname)
1da177e4 2860{
a2934c7b 2861 int rc;
1da177e4 2862 int xid;
7586b765 2863 struct smb_vol *volume_info;
a2934c7b
JL		 2864 struct cifsSesInfo *pSesInfo;
2865 struct cifsTconInfo *tcon;
2866 struct TCP_Server_Info *srvTcp;
e4cce94c 2867 char *full_path;
9d002df4 2868 struct tcon_link *tlink;
2d6d589d 2869#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8 2870 int referral_walks_count = 0;
1bfe73c2 2871try_mount_again:
dd613945
SF		 2872 /* cleanup activities if we're chasing a referral */
2873 if (referral_walks_count) {
2874 if (tcon)
2875 cifs_put_tcon(tcon);
2876 else if (pSesInfo)
2877 cifs_put_smb_ses(pSesInfo);
2878
2879 cleanup_volume_info(&volume_info);
2880 FreeXid(xid);
2881 }
2d6d589d 2882#endif
a2934c7b
JL		 2883 rc = 0;
2884 tcon = NULL;
2885 pSesInfo = NULL;
2886 srvTcp = NULL;
1bfe73c2 2887 full_path = NULL;
9d002df4 2888 tlink = NULL;
1da177e4
LT		 2889
2890 xid = GetXid();
2891
7586b765
JL		 2892 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2893 if (!volume_info) {
2894 rc = -ENOMEM;
2895 goto out;
2896 }
50c2f753 2897
f14bcf71
SF		 2898 if (cifs_parse_mount_options(cifs_sb->mountdata, devname,
2899 volume_info)) {
70fe7dc0
JL		 2900 rc = -EINVAL;
2901 goto out;
1da177e4
LT		 2902 }
2903
7586b765 2904 if (volume_info->nullauth) {
b6b38f70 2905 cFYI(1, "null user");
7586b765
JL		 2906 volume_info->username = "";
2907 } else if (volume_info->username) {
1da177e4 2908 /* BB fixme parse for domain name here */
b6b38f70 2909 cFYI(1, "Username: %s", volume_info->username);
1da177e4 2910 } else {
bf820679 2911 cifserror("No username specified");
50c2f753
SF		 2912 /* In userspace mount helper we can get user name from alternate
2913 locations such as env variables and files on disk */
70fe7dc0
JL		 2914 rc = -EINVAL;
2915 goto out;
1da177e4
LT		 2916 }
2917
1da177e4 2918 /* this is needed for ASCII cp to Unicode converts */
7586b765 2919 if (volume_info->iocharset == NULL) {
a5fc4ce0
JL		 2920 /* load_nls_default cannot return null */
2921 volume_info->local_nls = load_nls_default();
1da177e4 2922 } else {
a5fc4ce0
JL		 2923 volume_info->local_nls = load_nls(volume_info->iocharset);
2924 if (volume_info->local_nls == NULL) {
b6b38f70
JP		 2925 cERROR(1, "CIFS mount error: iocharset %s not found",
2926 volume_info->iocharset);
70fe7dc0
JL		 2927 rc = -ELIBACC;
2928 goto out;
1da177e4
LT		 2929 }
2930 }
a5fc4ce0 2931 cifs_sb->local_nls = volume_info->local_nls;
1da177e4 2932
63c038c2 2933 /* get a reference to a tcp session */
7586b765 2934 srvTcp = cifs_get_tcp_session(volume_info);
63c038c2
JL		 2935 if (IS_ERR(srvTcp)) {
2936 rc = PTR_ERR(srvTcp);
2937 goto out;
1da177e4
LT		 2938 }
2939
36988c76
JL		 2940 /* get a reference to a SMB session */
2941 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2942 if (IS_ERR(pSesInfo)) {
2943 rc = PTR_ERR(pSesInfo);
2944 pSesInfo = NULL;
2945 goto mount_fail_check;
1da177e4 2946 }
50c2f753 2947
d00c28de
JL		 2948 setup_cifs_sb(volume_info, cifs_sb);
2949 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2950 sb->s_maxbytes = MAX_LFS_FILESIZE;
2951 else
2952 sb->s_maxbytes = MAX_NON_LFS;
1da177e4 2953
8af18971 2954 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
1da177e4
LT		 2955 sb->s_time_gran = 100;
2956
d00c28de
JL		 2957 /* search for existing tcon to this server share */
2958 tcon = cifs_get_tcon(pSesInfo, volume_info);
2959 if (IS_ERR(tcon)) {
2960 rc = PTR_ERR(tcon);
2961 tcon = NULL;
1bfe73c2 2962 goto remote_path_check;
d00c28de 2963 }
1bfe73c2 2964
d82c2df5
SF		 2965 /* do not care if following two calls succeed - informational */
2966 if (!tcon->ipc) {
2967 CIFSSMBQFSDeviceInfo(xid, tcon);
2968 CIFSSMBQFSAttributeInfo(xid, tcon);
2969 }
03a143c9 2970
d82c2df5
SF		 2971 /* tell server which Unix caps we support */
2972 if (tcon->ses->capabilities & CAP_UNIX)
2973 /* reset of caps checks mount to see if unix extensions
2974 disabled for just this mount */
7586b765 2975 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
d82c2df5
SF		 2976 else
2977 tcon->unix_ext = 0; /* server does not support them */
c18c842b 2978
d82c2df5
SF		 2979 /* convert forward to back slashes in prepath here if needed */
2980 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2981 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
03a143c9 2982
d82c2df5
SF		 2983 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2984 cifs_sb->rsize = 1024 * 127;
b6b38f70 2985 cFYI(DBG2, "no very large read support, rsize now 127K");
1da177e4 2986 }
d82c2df5
SF		 2987 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2988 cifs_sb->wsize = min(cifs_sb->wsize,
2989 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2990 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2991 cifs_sb->rsize = min(cifs_sb->rsize,
2992 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
1da177e4 2993
1bfe73c2 2994remote_path_check:
c1508ca2
SF		 2995#ifdef CONFIG_CIFS_DFS_UPCALL
2996 /*
2997 * Perform an unconditional check for whether there are DFS
2998 * referrals for this path without prefix, to provide support
2999 * for DFS referrals from w2k8 servers which don't seem to respond
3000 * with PATH_NOT_COVERED to requests that include the prefix.
3001 * Chase the referral if found, otherwise continue normally.
3002 */
3003 if (referral_walks_count == 0) {
3004 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
046462ab 3005 cifs_sb, false);
c1508ca2
SF		 3006 if (!refrc) {
3007 referral_walks_count++;
3008 goto try_mount_again;
3009 }
3010 }
3011#endif
3012
1bfe73c2 3013 /* check if a whole path (including prepath) is not remote */
70945643 3014 if (!rc && tcon) {
e4cce94c 3015 /* build_path_to_root works only when we have a valid tcon */
7d161b7f 3016 full_path = cifs_build_path_to_root(cifs_sb, tcon);
e4cce94c
IM		 3017 if (full_path == NULL) {
3018 rc = -ENOMEM;
3019 goto mount_fail_check;
3020 }
3021 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
03ceace5 3022 if (rc != 0 && rc != -EREMOTE) {
e4cce94c
IM		 3023 kfree(full_path);
3024 goto mount_fail_check;
3025 }
3026 kfree(full_path);
3027 }
3028
1bfe73c2
IM		 3029 /* get referral if needed */
3030 if (rc == -EREMOTE) {
d036f50f 3031#ifdef CONFIG_CIFS_DFS_UPCALL
5c2503a8
IM		 3032 if (referral_walks_count > MAX_NESTED_LINKS) {
3033 /*
3034 * BB: when we implement proper loop detection,
3035 * we will remove this check. But now we need it
3036 * to prevent an indefinite loop if 'DFS tree' is
3037 * misconfigured (i.e. has loops).
3038 */
3039 rc = -ELOOP;
3040 goto mount_fail_check;
3041 }
1bfe73c2
IM		 3042 /* convert forward to back slashes in prepath here if needed */
3043 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
3044 convert_delimiter(cifs_sb->prepath,
3045 CIFS_DIR_SEP(cifs_sb));
1bfe73c2 3046
dd613945 3047 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
046462ab 3048 true);
7b91e266 3049
dd613945 3050 if (!rc) {
5c2503a8 3051 referral_walks_count++;
1bfe73c2
IM		 3052 goto try_mount_again;
3053 }
dd613945 3054 goto mount_fail_check;
d036f50f
SF		 3055#else /* No DFS support, return error on mount */
3056 rc = -EOPNOTSUPP;
3057#endif
1bfe73c2
IM		 3058 }
3059
9d002df4
JL		 3060 if (rc)
3061 goto mount_fail_check;
3062
3063 /* now, hang the tcon off of the superblock */
3064 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3065 if (tlink == NULL) {
3066 rc = -ENOMEM;
3067 goto mount_fail_check;
3068 }
3069
b647c35f 3070 tlink->tl_uid = pSesInfo->linux_uid;
9d002df4
JL		 3071 tlink->tl_tcon = tcon;
3072 tlink->tl_time = jiffies;
3073 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3074 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3075
b647c35f 3076 cifs_sb->master_tlink = tlink;
9d002df4 3077 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3078 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
9d002df4 3079 spin_unlock(&cifs_sb->tlink_tree_lock);
413e661c 3080
2de970ff
JL		 3081 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3082 TLINK_IDLE_EXPIRE);
3083
1bfe73c2
IM		 3084mount_fail_check:
3085 /* on error free sesinfo and tcon struct if needed */
3086 if (rc) {
1bfe73c2 3087 /* If find_unc succeeded then rc == 0 so we can not end */
25985edc 3088 /* up accidentally freeing someone elses tcon struct */
1bfe73c2
IM		 3089 if (tcon)
3090 cifs_put_tcon(tcon);
3091 else if (pSesInfo)
3092 cifs_put_smb_ses(pSesInfo);
3093 else
3094 cifs_put_tcp_session(srvTcp);
3095 goto out;
3096 }
3097
7586b765 3098 /* volume_info->password is freed above when existing session found
1da177e4
LT		 3099 (in which case it is not needed anymore) but when new sesion is created
3100 the password ptr is put in the new session structure (in which case the
3101 password will be freed at unmount time) */
70fe7dc0
JL		 3102out:
3103 /* zero out password before freeing */
1bfe73c2 3104 cleanup_volume_info(&volume_info);
1da177e4
LT		 3105 FreeXid(xid);
3106 return rc;
3107}
3108
1da177e4
LT		 3109int
3110CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
3111 const char *tree, struct cifsTconInfo *tcon,
3112 const struct nls_table *nls_codepage)
3113{
3114 struct smb_hdr *smb_buffer;
3115 struct smb_hdr *smb_buffer_response;
3116 TCONX_REQ *pSMB;
3117 TCONX_RSP *pSMBr;
3118 unsigned char *bcc_ptr;
3119 int rc = 0;
690c522f
JL		 3120 int length;
3121 __u16 bytes_left, count;
1da177e4
LT		 3122
3123 if (ses == NULL)
3124 return -EIO;
3125
3126 smb_buffer = cifs_buf_get();
ca43e3be 3127 if (smb_buffer == NULL)
1da177e4 3128 return -ENOMEM;
ca43e3be 3129
1da177e4
LT		 3130 smb_buffer_response = smb_buffer;
3131
3132 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3133 NULL /*no tid */ , 4 /*wct */ );
1982c344
SF		 3134
3135 smb_buffer->Mid = GetNextMid(ses->server);
1da177e4
LT		 3136 smb_buffer->Uid = ses->Suid;
3137 pSMB = (TCONX_REQ *) smb_buffer;
3138 pSMBr = (TCONX_RSP *) smb_buffer_response;
3139
3140 pSMB->AndXCommand = 0xFF;
3141 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
1da177e4 3142 bcc_ptr = &pSMB->Password[0];
fb8c4b14 3143 if ((ses->server->secMode) & SECMODE_USER) {
eeac8047 3144 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
7c7b25bc 3145 *bcc_ptr = 0; /* password is null byte */
eeac8047 3146 bcc_ptr++; /* skip password */
7c7b25bc 3147 /* already aligned so no need to do it below */
eeac8047 3148 } else {
540b2e37 3149 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
eeac8047
SF		 3150 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3151 specified as required (when that support is added to
3152 the vfs in the future) as only NTLM or the much
7c7b25bc 3153 weaker LANMAN (which we do not send by default) is accepted
eeac8047
SF		 3154 by Samba (not sure whether other servers allow
3155 NTLMv2 password here) */
7c7b25bc 3156#ifdef CONFIG_CIFS_WEAK_PW_HASH
04912d6a 3157 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
00e485b0 3158 (ses->server->secType == LANMAN))
d3ba50b1 3159 calc_lanman_hash(tcon->password, ses->server->cryptkey,
4e53a3fb
JL		 3160 ses->server->secMode &
3161 SECMODE_PW_ENCRYPT ? true : false,
3162 bcc_ptr);
7c7b25bc
SF		 3163 else
3164#endif /* CIFS_WEAK_PW_HASH */
ee2c9258
SP		 3165 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3166 bcc_ptr);
eeac8047 3167
540b2e37 3168 bcc_ptr += CIFS_AUTH_RESP_SIZE;
fb8c4b14 3169 if (ses->capabilities & CAP_UNICODE) {
7c7b25bc
SF		 3170 /* must align unicode strings */
3171 *bcc_ptr = 0; /* null byte password */
3172 bcc_ptr++;
3173 }
eeac8047 3174 }
1da177e4 3175
50c2f753 3176 if (ses->server->secMode &
a878fb22 3177 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1da177e4
LT		 3178 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3179
3180 if (ses->capabilities & CAP_STATUS32) {
3181 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3182 }
3183 if (ses->capabilities & CAP_DFS) {
3184 smb_buffer->Flags2 |= SMBFLG2_DFS;
3185 }
3186 if (ses->capabilities & CAP_UNICODE) {
3187 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3188 length =
50c2f753
SF		 3189 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3190 6 /* max utf8 char length in bytes */ *
a878fb22
SF		 3191 (/* server len*/ + 256 /* share len */), nls_codepage);
3192 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
1da177e4
LT		 3193 bcc_ptr += 2; /* skip trailing null */
3194 } else { /* ASCII */
1da177e4
LT		 3195 strcpy(bcc_ptr, tree);
3196 bcc_ptr += strlen(tree) + 1;
3197 }
3198 strcpy(bcc_ptr, "?????");
3199 bcc_ptr += strlen("?????");
3200 bcc_ptr += 1;
3201 count = bcc_ptr - &pSMB->Password[0];
be8e3b00
SF		 3202 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3203 pSMB->hdr.smb_buf_length) + count);
1da177e4
LT		 3204 pSMB->ByteCount = cpu_to_le16(count);
3205
133672ef 3206 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
7749981e 3207 0);
1da177e4 3208
1da177e4
LT		 3209 /* above now done in SendReceive */
3210 if ((rc == 0) && (tcon != NULL)) {
0e0d2cf3
SF		 3211 bool is_unicode;
3212
1da177e4 3213 tcon->tidStatus = CifsGood;
3b795210 3214 tcon->need_reconnect = false;
1da177e4
LT		 3215 tcon->tid = smb_buffer_response->Tid;
3216 bcc_ptr = pByteArea(smb_buffer_response);
690c522f 3217 bytes_left = get_bcc(smb_buffer_response);
cc20c031 3218 length = strnlen(bcc_ptr, bytes_left - 2);
0e0d2cf3
SF		 3219 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3220 is_unicode = true;
3221 else
3222 is_unicode = false;
3223
cc20c031 3224
50c2f753 3225 /* skip service field (NB: this field is always ASCII) */
7f8ed420
SF		 3226 if (length == 3) {
3227 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3228 (bcc_ptr[2] == 'C')) {
b6b38f70 3229 cFYI(1, "IPC connection");
7f8ed420
SF		 3230 tcon->ipc = 1;
3231 }
3232 } else if (length == 2) {
3233 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3234 /* the most common case */
b6b38f70 3235 cFYI(1, "disk share connection");
7f8ed420
SF		 3236 }
3237 }
50c2f753 3238 bcc_ptr += length + 1;
cc20c031 3239 bytes_left -= (length + 1);
1da177e4 3240 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
cc20c031
JL		 3241
3242 /* mostly informational -- no need to fail on error here */
90a98b2f 3243 kfree(tcon->nativeFileSystem);
d185cda7 3244 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
0e0d2cf3 3245 bytes_left, is_unicode,
cc20c031
JL		 3246 nls_codepage);
3247
b6b38f70 3248 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
cc20c031 3249
fb8c4b14 3250 if ((smb_buffer_response->WordCount == 3) ||
1a4e15a0
SF		 3251 (smb_buffer_response->WordCount == 7))
3252 /* field is in same location */
3979877e
SF		 3253 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3254 else
3255 tcon->Flags = 0;
b6b38f70 3256 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
1da177e4 3257 } else if ((rc == 0) && tcon == NULL) {
50c2f753 3258 /* all we need to save for IPC$ connection */
1da177e4
LT		 3259 ses->ipc_tid = smb_buffer_response->Tid;
3260 }
3261
a8a11d39 3262 cifs_buf_release(smb_buffer);
1da177e4
LT		 3263 return rc;
3264}
3265
3266int
3267cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3268{
b647c35f
JL		 3269 struct rb_root *root = &cifs_sb->tlink_tree;
3270 struct rb_node *node;
3271 struct tcon_link *tlink;
50c2f753 3272 char *tmp;
9d002df4 3273
2de970ff
JL		 3274 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3275
b647c35f
JL		 3276 spin_lock(&cifs_sb->tlink_tree_lock);
3277 while ((node = rb_first(root))) {
3278 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3279 cifs_get_tlink(tlink);
3280 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3281 rb_erase(node, root);
1da177e4 3282
b647c35f
JL		 3283 spin_unlock(&cifs_sb->tlink_tree_lock);
3284 cifs_put_tlink(tlink);
3285 spin_lock(&cifs_sb->tlink_tree_lock);
3286 }
3287 spin_unlock(&cifs_sb->tlink_tree_lock);
50c2f753 3288
2fe87f02
SF		 3289 tmp = cifs_sb->prepath;
3290 cifs_sb->prepathlen = 0;
3291 cifs_sb->prepath = NULL;
3292 kfree(tmp);
1da177e4 3293
9d002df4 3294 return 0;
50c2f753 3295}
1da177e4 3296
198b5682 3297int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
1da177e4
LT		 3298{
3299 int rc = 0;
198b5682 3300 struct TCP_Server_Info *server = ses->server;
1da177e4 3301
198b5682
JL		 3302 /* only send once per connect */
3303 if (server->maxBuf != 0)
3304 return 0;
3305
3306 rc = CIFSSMBNegotiate(xid, ses);
3307 if (rc == -EAGAIN) {
3308 /* retry only once on 1st time connection */
3309 rc = CIFSSMBNegotiate(xid, ses);
3310 if (rc == -EAGAIN)
3311 rc = -EHOSTDOWN;
1da177e4 3312 }
198b5682
JL		 3313 if (rc == 0) {
3314 spin_lock(&GlobalMid_Lock);
3315 if (server->tcpStatus != CifsExiting)
3316 server->tcpStatus = CifsGood;
3317 else
3318 rc = -EHOSTDOWN;
3319 spin_unlock(&GlobalMid_Lock);
26b994fa 3320
198b5682
JL		 3321 }
3322
3323 return rc;
3324}
3325
3326
3327int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3328 struct nls_table *nls_info)
3329{
3330 int rc = 0;
3331 struct TCP_Server_Info *server = ses->server;
26b994fa 3332
198b5682
JL		 3333 ses->flags = 0;
3334 ses->capabilities = server->capabilities;
26b994fa 3335 if (linuxExtEnabled == 0)
198b5682 3336 ses->capabilities &= (~CAP_UNIX);
20418acd 3337
b6b38f70
JP		 3338 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3339 server->secMode, server->capabilities, server->timeAdj);
cb7691b6 3340
198b5682 3341 rc = CIFS_SessSetup(xid, ses, nls_info);
26b994fa 3342 if (rc) {
b6b38f70 3343 cERROR(1, "Send error in SessSetup = %d", rc);
26b994fa 3344 } else {
5d0d2882
SP		 3345 mutex_lock(&ses->server->srv_mutex);
3346 if (!server->session_estab) {
21e73393 3347 server->session_key.response = ses->auth_key.response;
5d0d2882 3348 server->session_key.len = ses->auth_key.len;
21e73393
SP		 3349 server->sequence_number = 0x2;
3350 server->session_estab = true;
3351 ses->auth_key.response = NULL;
5d0d2882
SP		 3352 }
3353 mutex_unlock(&server->srv_mutex);
3354
b6b38f70 3355 cFYI(1, "CIFS Session Established successfully");
20418acd 3356 spin_lock(&GlobalMid_Lock);
198b5682
JL		 3357 ses->status = CifsGood;
3358 ses->need_reconnect = false;
20418acd 3359 spin_unlock(&GlobalMid_Lock);
1da177e4 3360 }
26b994fa 3361
21e73393
SP		 3362 kfree(ses->auth_key.response);
3363 ses->auth_key.response = NULL;
3364 ses->auth_key.len = 0;
d3686d54
SP		 3365 kfree(ses->ntlmssp);
3366 ses->ntlmssp = NULL;
21e73393 3367
1da177e4
LT		 3368 return rc;
3369}
3370
d2445556 3371static struct cifsTconInfo *
9d002df4
JL		 3372cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3373{
3374 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3375 struct cifsSesInfo *ses;
3376 struct cifsTconInfo *tcon = NULL;
3377 struct smb_vol *vol_info;
34c87901
SF		 3378 char username[28]; /* big enough for "krb50x" + hex of ULONG_MAX 6+16 */
3379 /* We used to have this as MAX_USERNAME which is */
3380 /* way too big now (256 instead of 32) */
9d002df4
JL		 3381
3382 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3383 if (vol_info == NULL) {
3384 tcon = ERR_PTR(-ENOMEM);
3385 goto out;
3386 }
3387
3388 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3389 vol_info->username = username;
3390 vol_info->local_nls = cifs_sb->local_nls;
3391 vol_info->linux_uid = fsuid;
3392 vol_info->cred_uid = fsuid;
3393 vol_info->UNC = master_tcon->treeName;
3394 vol_info->retry = master_tcon->retry;
3395 vol_info->nocase = master_tcon->nocase;
3396 vol_info->local_lease = master_tcon->local_lease;
3397 vol_info->no_linux_ext = !master_tcon->unix_ext;
3398
3399 /* FIXME: allow for other secFlg settings */
3400 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3401
3402 /* get a reference for the same TCP session */
3f9bcca7 3403 spin_lock(&cifs_tcp_ses_lock);
9d002df4 3404 ++master_tcon->ses->server->srv_count;
3f9bcca7 3405 spin_unlock(&cifs_tcp_ses_lock);
9d002df4
JL		 3406
3407 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3408 if (IS_ERR(ses)) {
3409 tcon = (struct cifsTconInfo *)ses;
3410 cifs_put_tcp_session(master_tcon->ses->server);
3411 goto out;
3412 }
3413
3414 tcon = cifs_get_tcon(ses, vol_info);
3415 if (IS_ERR(tcon)) {
3416 cifs_put_smb_ses(ses);
3417 goto out;
3418 }
3419
3420 if (ses->capabilities & CAP_UNIX)
3421 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3422out:
3423 kfree(vol_info);
3424
3425 return tcon;
3426}
3427
413e661c 3428static inline struct tcon_link *
9d002df4
JL		 3429cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3430{
413e661c 3431 return cifs_sb->master_tlink;
9d002df4
JL		 3432}
3433
3434struct cifsTconInfo *
3435cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3436{
3437 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3438}
3439
3440static int
3441cifs_sb_tcon_pending_wait(void *unused)
3442{
3443 schedule();
3444 return signal_pending(current) ? -ERESTARTSYS : 0;
3445}
3446
b647c35f
JL		 3447/* find and return a tlink with given uid */
3448static struct tcon_link *
3449tlink_rb_search(struct rb_root *root, uid_t uid)
3450{
3451 struct rb_node *node = root->rb_node;
3452 struct tcon_link *tlink;
3453
3454 while (node) {
3455 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3456
3457 if (tlink->tl_uid > uid)
3458 node = node->rb_left;
3459 else if (tlink->tl_uid < uid)
3460 node = node->rb_right;
3461 else
3462 return tlink;
3463 }
3464 return NULL;
3465}
3466
3467/* insert a tcon_link into the tree */
3468static void
3469tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3470{
3471 struct rb_node **new = &(root->rb_node), *parent = NULL;
3472 struct tcon_link *tlink;
3473
3474 while (*new) {
3475 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3476 parent = *new;
3477
3478 if (tlink->tl_uid > new_tlink->tl_uid)
3479 new = &((*new)->rb_left);
3480 else
3481 new = &((*new)->rb_right);
3482 }
3483
3484 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3485 rb_insert_color(&new_tlink->tl_rbnode, root);
3486}
3487
9d002df4
JL		 3488/*
3489 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3490 * current task.
3491 *
3492 * If the superblock doesn't refer to a multiuser mount, then just return
3493 * the master tcon for the mount.
3494 *
6ef933a3 3495 * First, search the rbtree for an existing tcon for this fsuid. If one
9d002df4
JL		 3496 * exists, then check to see if it's pending construction. If it is then wait
3497 * for construction to complete. Once it's no longer pending, check to see if
3498 * it failed and either return an error or retry construction, depending on
3499 * the timeout.
3500 *
3501 * If one doesn't exist then insert a new tcon_link struct into the tree and
3502 * try to construct a new one.
3503 */
3504struct tcon_link *
3505cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3506{
3507 int ret;
b647c35f 3508 uid_t fsuid = current_fsuid();
9d002df4
JL		 3509 struct tcon_link *tlink, *newtlink;
3510
3511 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3512 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3513
3514 spin_lock(&cifs_sb->tlink_tree_lock);
b647c35f 3515 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 3516 if (tlink)
3517 cifs_get_tlink(tlink);
3518 spin_unlock(&cifs_sb->tlink_tree_lock);
3519
3520 if (tlink == NULL) {
3521 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3522 if (newtlink == NULL)
3523 return ERR_PTR(-ENOMEM);
b647c35f 3524 newtlink->tl_uid = fsuid;
9d002df4
JL		 3525 newtlink->tl_tcon = ERR_PTR(-EACCES);
3526 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3527 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3528 cifs_get_tlink(newtlink);
3529
9d002df4
JL		 3530 spin_lock(&cifs_sb->tlink_tree_lock);
3531 /* was one inserted after previous search? */
b647c35f 3532 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
9d002df4
JL		 3533 if (tlink) {
3534 cifs_get_tlink(tlink);
3535 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 3536 kfree(newtlink);
3537 goto wait_for_construction;
3538 }
9d002df4 3539 tlink = newtlink;
b647c35f
JL		 3540 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3541 spin_unlock(&cifs_sb->tlink_tree_lock);
9d002df4
JL		 3542 } else {
3543wait_for_construction:
3544 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3545 cifs_sb_tcon_pending_wait,
3546 TASK_INTERRUPTIBLE);
3547 if (ret) {
3548 cifs_put_tlink(tlink);
3549 return ERR_PTR(ret);
3550 }
3551
3552 /* if it's good, return it */
3553 if (!IS_ERR(tlink->tl_tcon))
3554 return tlink;
3555
3556 /* return error if we tried this already recently */
3557 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3558 cifs_put_tlink(tlink);
3559 return ERR_PTR(-EACCES);
3560 }
3561
3562 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3563 goto wait_for_construction;
3564 }
3565
3566 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3567 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3568 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3569
3570 if (IS_ERR(tlink->tl_tcon)) {
3571 cifs_put_tlink(tlink);
3572 return ERR_PTR(-EACCES);
3573 }
3574
3575 return tlink;
3576}
2de970ff
JL		 3577
3578/*
3579 * periodic workqueue job that scans tcon_tree for a superblock and closes
3580 * out tcons.
3581 */
3582static void
3583cifs_prune_tlinks(struct work_struct *work)
3584{
3585 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3586 prune_tlinks.work);
b647c35f
JL		 3587 struct rb_root *root = &cifs_sb->tlink_tree;
3588 struct rb_node *node = rb_first(root);
3589 struct rb_node *tmp;
3590 struct tcon_link *tlink;
2de970ff 3591
b647c35f
JL		 3592 /*
3593 * Because we drop the spinlock in the loop in order to put the tlink
3594 * it's not guarded against removal of links from the tree. The only
3595 * places that remove entries from the tree are this function and
3596 * umounts. Because this function is non-reentrant and is canceled
3597 * before umount can proceed, this is safe.
3598 */
3599 spin_lock(&cifs_sb->tlink_tree_lock);
3600 node = rb_first(root);
3601 while (node != NULL) {
3602 tmp = node;
3603 node = rb_next(tmp);
3604 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3605
3606 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3607 atomic_read(&tlink->tl_count) != 0 ||
3608 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3609 continue;
2de970ff 3610
b647c35f
JL		 3611 cifs_get_tlink(tlink);
3612 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3613 rb_erase(tmp, root);
3614
3615 spin_unlock(&cifs_sb->tlink_tree_lock);
3616 cifs_put_tlink(tlink);
3617 spin_lock(&cifs_sb->tlink_tree_lock);
3618 }
3619 spin_unlock(&cifs_sb->tlink_tree_lock);
2de970ff
JL		 3620
3621 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3622 TLINK_IDLE_EXPIRE);
3623}
Linux kernel - Deliverables
This page took 1.442067 seconds and 5 git commands to generate.