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