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