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