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