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