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