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