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