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