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