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