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