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