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