blob: 7ae03283bd61c128c6c804805c30c6c25da79f31 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/connect.c
3 *
Steve French1080ef72011-02-24 18:07:19 +00004 * Copyright (C) International Business Machines Corp., 2002,2011
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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
Steve Frenchfb8c4b12007-07-10 01:16:18 +000019 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 */
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090026#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
Steve Frenchb8643e12005-04-28 22:41:07 -070031#include <linux/delay.h>
Steve Frenchf1914012005-08-18 09:37:34 -070032#include <linux/completion.h>
Igor Mammedovaaf737a2007-04-03 19:16:43 +000033#include <linux/kthread.h>
Steve French0ae0efa2005-10-10 10:57:19 -070034#include <linux/pagevec.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080035#include <linux/freezer.h>
Igor Mammedov5c2503a2009-04-21 19:31:05 +040036#include <linux/namei.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38#include <asm/processor.h>
Jeff Layton50b64e32009-06-02 06:55:20 -040039#include <linux/inet.h>
Paul Gortmaker143cb492011-07-01 14:23:34 -040040#include <linux/module.h>
Jeff Layton8a8798a2012-01-17 16:09:15 -050041#include <keys/user-type.h>
Steve French0e2beda2009-01-30 21:24:41 +000042#include <net/ipv6.h>
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040043#include <linux/parser.h>
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#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"
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +053054#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059extern mempool_t *cifs_req_poolp;
60
Jeff Layton2de970f2010-10-06 19:51:12 -040061/* FIXME: should these be tunable? */
Jeff Layton9d002df2010-10-06 19:51:11 -040062#define TLINK_ERROR_EXPIRE (1 * HZ)
Jeff Layton2de970f2010-10-06 19:51:12 -040063#define TLINK_IDLE_EXPIRE (600 * HZ)
Jeff Layton9d002df2010-10-06 19:51:11 -040064
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040065enum {
66
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
Jeff Layton72bd4812012-10-03 16:02:36 -040070 Opt_forcegid, Opt_noforcegid,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040071 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
Steve French2baa2682014-09-27 02:19:01 -050073 Opt_mapposix, Opt_nomapposix,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040074 Opt_mapchars, Opt_nomapchars, Opt_sfu,
75 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
76 Opt_noposixpaths, Opt_nounix,
77 Opt_nocase,
78 Opt_brl, Opt_nobrl,
79 Opt_forcemandatorylock, Opt_setuids,
80 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
81 Opt_nohard, Opt_nosoft,
82 Opt_nointr, Opt_intr,
83 Opt_nostrictsync, Opt_strictsync,
84 Opt_serverino, Opt_noserverino,
85 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
86 Opt_acl, Opt_noacl, Opt_locallease,
Jeff Layton1b359202012-09-19 15:20:27 -070087 Opt_sign, Opt_seal, Opt_noac,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040088 Opt_fsc, Opt_mfsymlinks,
Jeff Laytona0b3df52013-05-24 07:40:59 -040089 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
Steve Frenchb2a30772015-09-29 21:49:28 -050090 Opt_persistent, Opt_nopersistent,
Steve French592fafe2015-11-03 10:08:53 -060091 Opt_resilient, Opt_noresilient,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040092
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,
Steve Frenchadfeb3e2015-12-18 12:31:36 -060098 Opt_echo_interval,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040099
100 /* Mount options which take string value */
101 Opt_user, Opt_pass, Opt_ip,
Jeff Layton73a999f2013-03-22 08:42:57 -0400102 Opt_domain, Opt_srcaddr, Opt_iocharset,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400103 Opt_netbiosname, Opt_servern,
Jeff Layton23db65f2012-05-15 12:20:51 -0400104 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400105
106 /* Mount options to be ignored */
107 Opt_ignore,
108
109 /* Options which could be blank */
110 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100111 Opt_blank_user,
112 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400113
114 Opt_err
115};
116
117static const match_table_t cifs_mount_option_tokens = {
118
119 { Opt_user_xattr, "user_xattr" },
120 { Opt_nouser_xattr, "nouser_xattr" },
121 { Opt_forceuid, "forceuid" },
122 { Opt_noforceuid, "noforceuid" },
Jeff Layton72bd4812012-10-03 16:02:36 -0400123 { Opt_forcegid, "forcegid" },
124 { Opt_noforcegid, "noforcegid" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400125 { Opt_noblocksend, "noblocksend" },
126 { Opt_noautotune, "noautotune" },
127 { Opt_hard, "hard" },
128 { Opt_soft, "soft" },
129 { Opt_perm, "perm" },
130 { Opt_noperm, "noperm" },
Steve French2baa2682014-09-27 02:19:01 -0500131 { Opt_mapchars, "mapchars" }, /* SFU style */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400132 { Opt_nomapchars, "nomapchars" },
Steve French2baa2682014-09-27 02:19:01 -0500133 { Opt_mapposix, "mapposix" }, /* SFM style */
134 { Opt_nomapposix, "nomapposix" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400135 { Opt_sfu, "sfu" },
136 { Opt_nosfu, "nosfu" },
137 { Opt_nodfs, "nodfs" },
138 { Opt_posixpaths, "posixpaths" },
139 { Opt_noposixpaths, "noposixpaths" },
140 { Opt_nounix, "nounix" },
141 { Opt_nounix, "nolinux" },
142 { Opt_nocase, "nocase" },
143 { Opt_nocase, "ignorecase" },
144 { Opt_brl, "brl" },
145 { Opt_nobrl, "nobrl" },
146 { Opt_nobrl, "nolock" },
147 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400148 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400149 { Opt_setuids, "setuids" },
150 { Opt_nosetuids, "nosetuids" },
151 { Opt_dynperm, "dynperm" },
152 { Opt_nodynperm, "nodynperm" },
153 { Opt_nohard, "nohard" },
154 { Opt_nosoft, "nosoft" },
155 { Opt_nointr, "nointr" },
156 { Opt_intr, "intr" },
157 { Opt_nostrictsync, "nostrictsync" },
158 { Opt_strictsync, "strictsync" },
159 { Opt_serverino, "serverino" },
160 { Opt_noserverino, "noserverino" },
161 { Opt_rwpidforward, "rwpidforward" },
162 { Opt_cifsacl, "cifsacl" },
163 { Opt_nocifsacl, "nocifsacl" },
164 { Opt_acl, "acl" },
165 { Opt_noacl, "noacl" },
166 { Opt_locallease, "locallease" },
167 { Opt_sign, "sign" },
168 { Opt_seal, "seal" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400169 { Opt_noac, "noac" },
170 { Opt_fsc, "fsc" },
171 { Opt_mfsymlinks, "mfsymlinks" },
172 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400173 { Opt_sloppy, "sloppy" },
Jeff Laytona0b3df52013-05-24 07:40:59 -0400174 { Opt_nosharesock, "nosharesock" },
Steve Frenchb2a30772015-09-29 21:49:28 -0500175 { Opt_persistent, "persistenthandles"},
176 { Opt_nopersistent, "nopersistenthandles"},
Steve French592fafe2015-11-03 10:08:53 -0600177 { Opt_resilient, "resilienthandles"},
178 { Opt_noresilient, "noresilienthandles"},
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400179
180 { Opt_backupuid, "backupuid=%s" },
181 { Opt_backupgid, "backupgid=%s" },
182 { Opt_uid, "uid=%s" },
183 { Opt_cruid, "cruid=%s" },
184 { Opt_gid, "gid=%s" },
185 { Opt_file_mode, "file_mode=%s" },
186 { Opt_dirmode, "dirmode=%s" },
187 { Opt_dirmode, "dir_mode=%s" },
188 { Opt_port, "port=%s" },
189 { Opt_rsize, "rsize=%s" },
190 { Opt_wsize, "wsize=%s" },
191 { Opt_actimeo, "actimeo=%s" },
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600192 { Opt_echo_interval, "echo_interval=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400193
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100194 { Opt_blank_user, "user=" },
195 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400196 { Opt_user, "user=%s" },
197 { Opt_user, "username=%s" },
198 { Opt_blank_pass, "pass=" },
Jesper Nilsson3c15b4c2012-11-29 17:31:16 +0100199 { Opt_blank_pass, "password=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400200 { Opt_pass, "pass=%s" },
201 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100202 { Opt_blank_ip, "ip=" },
203 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400204 { Opt_ip, "ip=%s" },
205 { Opt_ip, "addr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400206 { Opt_ignore, "unc=%s" },
207 { Opt_ignore, "target=%s" },
208 { Opt_ignore, "path=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400209 { Opt_domain, "dom=%s" },
210 { Opt_domain, "domain=%s" },
211 { Opt_domain, "workgroup=%s" },
212 { Opt_srcaddr, "srcaddr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400213 { Opt_ignore, "prefixpath=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400214 { Opt_iocharset, "iocharset=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400215 { Opt_netbiosname, "netbiosname=%s" },
216 { Opt_servern, "servern=%s" },
217 { Opt_ver, "ver=%s" },
Jeff Layton23db65f2012-05-15 12:20:51 -0400218 { Opt_vers, "vers=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400219 { Opt_sec, "sec=%s" },
Jeff Layton15b6a472012-05-16 07:50:15 -0400220 { Opt_cache, "cache=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400221
222 { Opt_ignore, "cred" },
223 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400224 { Opt_ignore, "cred=%s" },
225 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400226 { Opt_ignore, "guest" },
227 { Opt_ignore, "rw" },
228 { Opt_ignore, "ro" },
229 { Opt_ignore, "suid" },
230 { Opt_ignore, "nosuid" },
231 { Opt_ignore, "exec" },
232 { Opt_ignore, "noexec" },
233 { Opt_ignore, "nodev" },
234 { Opt_ignore, "noauto" },
235 { Opt_ignore, "dev" },
236 { Opt_ignore, "mand" },
237 { Opt_ignore, "nomand" },
238 { Opt_ignore, "_netdev" },
239
240 { Opt_err, NULL }
241};
242
243enum {
244 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
245 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
Jeff Layton76596242012-07-23 20:34:17 -0400246 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
247 Opt_sec_ntlmv2i, Opt_sec_lanman,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400248 Opt_sec_none,
249
250 Opt_sec_err
251};
252
253static const match_table_t cifs_secflavor_tokens = {
254 { Opt_sec_krb5, "krb5" },
255 { Opt_sec_krb5i, "krb5i" },
256 { Opt_sec_krb5p, "krb5p" },
257 { Opt_sec_ntlmsspi, "ntlmsspi" },
258 { Opt_sec_ntlmssp, "ntlmssp" },
259 { Opt_ntlm, "ntlm" },
260 { Opt_sec_ntlmi, "ntlmi" },
Jeff Layton76596242012-07-23 20:34:17 -0400261 { Opt_sec_ntlmv2, "nontlm" },
262 { Opt_sec_ntlmv2, "ntlmv2" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400263 { Opt_sec_ntlmv2i, "ntlmv2i" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400264 { Opt_sec_lanman, "lanman" },
265 { Opt_sec_none, "none" },
266
267 { Opt_sec_err, NULL }
268};
269
Jeff Layton15b6a472012-05-16 07:50:15 -0400270/* cache flavors */
271enum {
272 Opt_cache_loose,
273 Opt_cache_strict,
274 Opt_cache_none,
275 Opt_cache_err
276};
277
278static const match_table_t cifs_cacheflavor_tokens = {
279 { Opt_cache_loose, "loose" },
280 { Opt_cache_strict, "strict" },
281 { Opt_cache_none, "none" },
282 { Opt_cache_err, NULL }
283};
284
Jeff Layton23db65f2012-05-15 12:20:51 -0400285static const match_table_t cifs_smb_version_tokens = {
286 { Smb_1, SMB1_VERSION_STRING },
Steve Frenchdd446b12012-11-28 23:21:06 -0600287 { Smb_20, SMB20_VERSION_STRING},
Steve French1080ef72011-02-24 18:07:19 +0000288 { Smb_21, SMB21_VERSION_STRING },
Steve Frenche4aa25e2012-10-01 12:26:22 -0500289 { Smb_30, SMB30_VERSION_STRING },
Steve French20b6d8b2013-06-12 22:48:41 -0500290 { Smb_302, SMB302_VERSION_STRING },
Steve French5f7fbf72014-12-17 22:52:58 -0600291#ifdef CONFIG_CIFS_SMB311
292 { Smb_311, SMB311_VERSION_STRING },
Steve Frenchaab18932015-06-23 23:37:11 -0500293 { Smb_311, ALT_SMB311_VERSION_STRING },
Steve French5f7fbf72014-12-17 22:52:58 -0600294#endif /* SMB311 */
295 { Smb_version_err, NULL }
Jeff Layton23db65f2012-05-15 12:20:51 -0400296};
297
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300298static int ip_connect(struct TCP_Server_Info *server);
299static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400300static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400301static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400302static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
303 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Jeff Laytond5c56052008-12-01 18:42:33 -0500305/*
306 * cifs tcp session reconnection
307 *
308 * mark tcp session as reconnecting so temporarily locked
309 * mark all smb sessions as reconnecting for tcp session
310 * reconnect tcp session
311 * wake up waiters on reconnection? - (not needed currently)
312 */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400313int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314cifs_reconnect(struct TCP_Server_Info *server)
315{
316 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500317 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000318 struct cifs_ses *ses;
319 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000320 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400321 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000324 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000325 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 next time through the loop */
327 spin_unlock(&GlobalMid_Lock);
328 return rc;
329 } else
330 server->tcpStatus = CifsNeedReconnect;
331 spin_unlock(&GlobalMid_Lock);
332 server->maxBuf = 0;
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400333#ifdef CONFIG_CIFS_SMB2
334 server->max_read = 0;
335#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Joe Perchesf96637b2013-05-04 22:12:25 -0500337 cifs_dbg(FYI, "Reconnecting tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 /* before reconnecting the tcp session, mark the smb session (uid)
340 and the tid bad so they are not used until reconnected */
Joe Perchesf96637b2013-05-04 22:12:25 -0500341 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
342 __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530343 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500344 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000345 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500346 ses->need_reconnect = true;
347 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500348 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000349 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500350 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530353 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 /* do not want to be sending data on a socket we are freeing */
Joe Perchesf96637b2013-05-04 22:12:25 -0500356 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500357 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000358 if (server->ssocket) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500359 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
360 server->ssocket->state, server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800361 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesf96637b2013-05-04 22:12:25 -0500362 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
363 server->ssocket->state, server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 sock_release(server->ssocket);
365 server->ssocket = NULL;
366 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500367 server->sequence_number = 0;
368 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500369 kfree(server->session_key.response);
370 server->session_key.response = NULL;
371 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000372 server->lstrp = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500374 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400375 INIT_LIST_HEAD(&retry_list);
Joe Perchesf96637b2013-05-04 22:12:25 -0500376 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500378 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
379 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400380 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
381 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400382 list_move(&mid_entry->qhead, &retry_list);
383 }
384 spin_unlock(&GlobalMid_Lock);
Rabin Vincent820962d2015-12-23 07:32:41 +0100385 mutex_unlock(&server->srv_mutex);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400386
Joe Perchesf96637b2013-05-04 22:12:25 -0500387 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400388 list_for_each_safe(tmp, tmp2, &retry_list) {
389 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500390 list_del_init(&mid_entry->qhead);
391 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400394 do {
Steve French6c3d8902006-07-31 22:46:20 +0000395 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300396
397 /* we should try only the port we connected to before */
Jeff Layton73e216a2013-09-05 08:38:10 -0400398 mutex_lock(&server->srv_mutex);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300399 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000400 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500401 cifs_dbg(FYI, "reconnect error %d\n", rc);
Federico Sauter4afe2602015-03-17 17:45:28 +0100402 mutex_unlock(&server->srv_mutex);
Steve French0cb766a2005-04-28 22:41:11 -0700403 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 } else {
405 atomic_inc(&tcpSesReconnectCount);
406 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000407 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000408 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000409 spin_unlock(&GlobalMid_Lock);
Federico Sauter4afe2602015-03-17 17:45:28 +0100410 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400412 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return rc;
415}
416
Jeff Laytonc74093b2011-01-11 07:24:23 -0500417static void
418cifs_echo_request(struct work_struct *work)
419{
420 int rc;
421 struct TCP_Server_Info *server = container_of(work,
422 struct TCP_Server_Info, echo.work);
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600423 unsigned long echo_interval = server->echo_interval;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500424
Jeff Layton247ec9b2011-02-04 17:09:50 -0500425 /*
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400426 * We cannot send an echo if it is disabled or until the
427 * NEGOTIATE_PROTOCOL request is done, which is indicated by
428 * server->ops->need_neg() == true. Also, no need to ping if
429 * we got a response recently.
Jeff Layton247ec9b2011-02-04 17:09:50 -0500430 */
Steve French4fcd1812016-06-22 20:12:05 -0500431
432 if (server->tcpStatus == CifsNeedReconnect ||
433 server->tcpStatus == CifsExiting || server->tcpStatus == CifsNew ||
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400434 (server->ops->can_echo && !server->ops->can_echo(server)) ||
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600435 time_before(jiffies, server->lstrp + echo_interval - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500436 goto requeue_echo;
437
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400438 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500439 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500440 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
441 server->hostname);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500442
443requeue_echo:
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600444 queue_delayed_work(cifsiod_wq, &server->echo, echo_interval);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500445}
446
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400447static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400448allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400449{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400450 if (!server->bigbuf) {
451 server->bigbuf = (char *)cifs_buf_get();
452 if (!server->bigbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500453 cifs_dbg(VFS, "No memory for large SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400454 msleep(3000);
455 /* retry will check if exiting */
456 return false;
457 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400458 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400459 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400460 memset(server->bigbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400461 }
462
Jeff Layton2a37ef92011-10-19 15:29:23 -0400463 if (!server->smallbuf) {
464 server->smallbuf = (char *)cifs_small_buf_get();
465 if (!server->smallbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500466 cifs_dbg(VFS, "No memory for SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400467 msleep(1000);
468 /* retry will check if exiting */
469 return false;
470 }
471 /* beginning of smb buffer is cleared in our buf_get */
472 } else {
473 /* if existing small buf clear beginning */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400474 memset(server->smallbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400475 }
476
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400477 return true;
478}
479
Jeff Laytonba749e62011-10-11 06:41:32 -0400480static bool
481server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400482{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300483 /*
484 * We need to wait 2 echo intervals to make sure we handle such
485 * situations right:
486 * 1s client sends a normal SMB request
487 * 2s client gets a response
488 * 30s echo workqueue job pops, and decides we got a response recently
489 * and don't need to send another
490 * ...
491 * 65s kernel_recvmsg times out, and we see that we haven't gotten
492 * a response in >60s.
493 */
494 if (server->tcpStatus == CifsGood &&
Steve Frenchadfeb3e2015-12-18 12:31:36 -0600495 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
496 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
497 server->hostname, (2 * server->echo_interval) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400498 cifs_reconnect(server);
499 wake_up(&server->response_q);
500 return true;
501 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400502
Jeff Laytonba749e62011-10-11 06:41:32 -0400503 return false;
504}
505
Al Viro71335662016-01-09 19:54:50 -0500506static int
507cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400508{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400509 int length = 0;
510 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400511
Al Viro71335662016-01-09 19:54:50 -0500512 smb_msg->msg_control = NULL;
513 smb_msg->msg_controllen = 0;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400514
Al Viro71335662016-01-09 19:54:50 -0500515 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500516 try_to_freeze();
517
Al Viro71335662016-01-09 19:54:50 -0500518 if (server_unresponsive(server))
519 return -ECONNABORTED;
520
521 length = sock_recvmsg(server->ssocket, smb_msg, 0);
522
523 if (server->tcpStatus == CifsExiting)
524 return -ESHUTDOWN;
525
526 if (server->tcpStatus == CifsNeedReconnect) {
527 cifs_reconnect(server);
528 return -ECONNABORTED;
Jeff Laytonba749e62011-10-11 06:41:32 -0400529 }
530
Al Viro71335662016-01-09 19:54:50 -0500531 if (length == -ERESTARTSYS ||
532 length == -EAGAIN ||
533 length == -EINTR) {
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400534 /*
535 * Minimum sleep to prevent looping, allowing socket
536 * to clear and app threads to set tcpStatus
537 * CifsNeedReconnect if server hung.
538 */
539 usleep_range(1000, 2000);
540 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400541 continue;
Al Viro71335662016-01-09 19:54:50 -0500542 }
543
544 if (length <= 0) {
Al Viro09aab882015-11-13 03:00:17 -0500545 cifs_dbg(FYI, "Received no data or error: %d\n", length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400546 cifs_reconnect(server);
Al Viro71335662016-01-09 19:54:50 -0500547 return -ECONNABORTED;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400548 }
549 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400550 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400551}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400552
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400553int
554cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
555 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400556{
Al Viro71335662016-01-09 19:54:50 -0500557 struct msghdr smb_msg;
558 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
559 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400560
Al Viro71335662016-01-09 19:54:50 -0500561 return cifs_readv_from_socket(server, &smb_msg);
562}
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400563
Al Viro71335662016-01-09 19:54:50 -0500564int
565cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
566 unsigned int to_read)
567{
568 struct msghdr smb_msg;
569 struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
570 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
571 return cifs_readv_from_socket(server, &smb_msg);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400572}
573
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400574static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400575is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400576{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400577 /*
578 * The first byte big endian of the length field,
579 * is actually not part of the length but the type
580 * with the most common, zero, as regular data.
581 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400582 switch (type) {
583 case RFC1002_SESSION_MESSAGE:
584 /* Regular SMB response */
585 return true;
586 case RFC1002_SESSION_KEEP_ALIVE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500587 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400588 break;
589 case RFC1002_POSITIVE_SESSION_RESPONSE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500590 cifs_dbg(FYI, "RFC 1002 positive session response\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400591 break;
592 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400593 /*
594 * We get this from Windows 98 instead of an error on
595 * SMB negprot response.
596 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500597 cifs_dbg(FYI, "RFC 1002 negative session response\n");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400598 /* give server a second to clean up */
599 msleep(1000);
600 /*
601 * Always try 445 first on reconnect since we get NACK
602 * on some if we ever connected to port 139 (the NACK
603 * is since we do not begin with RFC1001 session
604 * initialize frame).
605 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400606 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400607 cifs_reconnect(server);
608 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400609 break;
610 default:
Joe Perchesf96637b2013-05-04 22:12:25 -0500611 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400612 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400613 }
614
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400615 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400616}
617
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400618void
619dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400620{
621#ifdef CONFIG_CIFS_STATS2
622 mid->when_received = jiffies;
623#endif
624 spin_lock(&GlobalMid_Lock);
625 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400626 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400627 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400628 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400629 list_del_init(&mid->qhead);
630 spin_unlock(&GlobalMid_Lock);
631}
632
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400633static void
634handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400635 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400636{
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400637 if (server->ops->check_trans2 &&
638 server->ops->check_trans2(mid, server, buf, malformed))
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400639 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400640 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400641 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400642 /* Was previous buf put in mpx struct for multi-rsp? */
643 if (!mid->multiRsp) {
644 /* smb buffer will be freed by user thread */
645 if (server->large_buf)
646 server->bigbuf = NULL;
647 else
648 server->smallbuf = NULL;
649 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400650 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400651}
652
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400653static void clean_demultiplex_info(struct TCP_Server_Info *server)
654{
655 int length;
656
657 /* take it off the list, if it's not already */
658 spin_lock(&cifs_tcp_ses_lock);
659 list_del_init(&server->tcp_ses_list);
660 spin_unlock(&cifs_tcp_ses_lock);
661
662 spin_lock(&GlobalMid_Lock);
663 server->tcpStatus = CifsExiting;
664 spin_unlock(&GlobalMid_Lock);
665 wake_up_all(&server->response_q);
666
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400667 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300668 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400669 if (server->credits <= 0)
670 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300671 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400672 /*
673 * Although there should not be any requests blocked on this queue it
674 * can not hurt to be paranoid and try to wake up requests that may
675 * haven been blocked when more than 50 at time were on the wire to the
676 * same server - they now will see the session is in exit state and get
677 * out of SendReceive.
678 */
679 wake_up_all(&server->request_q);
680 /* give those requests time to exit */
681 msleep(125);
682
683 if (server->ssocket) {
684 sock_release(server->ssocket);
685 server->ssocket = NULL;
686 }
687
688 if (!list_empty(&server->pending_mid_q)) {
689 struct list_head dispose_list;
690 struct mid_q_entry *mid_entry;
691 struct list_head *tmp, *tmp2;
692
693 INIT_LIST_HEAD(&dispose_list);
694 spin_lock(&GlobalMid_Lock);
695 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
696 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500697 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400698 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400699 list_move(&mid_entry->qhead, &dispose_list);
700 }
701 spin_unlock(&GlobalMid_Lock);
702
703 /* now walk dispose list and issue callbacks */
704 list_for_each_safe(tmp, tmp2, &dispose_list) {
705 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500706 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400707 list_del_init(&mid_entry->qhead);
708 mid_entry->callback(mid_entry);
709 }
710 /* 1/8th of sec is more than enough time for them to exit */
711 msleep(125);
712 }
713
714 if (!list_empty(&server->pending_mid_q)) {
715 /*
716 * mpx threads have not exited yet give them at least the smb
717 * send timeout time for long ops.
718 *
719 * Due to delays on oplock break requests, we need to wait at
720 * least 45 seconds before giving up on a request getting a
721 * response and going ahead and killing cifsd.
722 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500723 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400724 msleep(46000);
725 /*
726 * If threads still have not exited they are probably never
727 * coming home not much else we can do but free the memory.
728 */
729 }
730
731 kfree(server->hostname);
732 kfree(server);
733
734 length = atomic_dec_return(&tcpSesAllocCount);
735 if (length > 0)
David Rientjes11d83362015-04-14 15:48:21 -0700736 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400737}
738
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400739static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400740standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
741{
742 int length;
743 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400744 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400745
746 /* make sure this will fit in a large buffer */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400747 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500748 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400749 cifs_reconnect(server);
750 wake_up(&server->response_q);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400751 return -ECONNABORTED;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400752 }
753
754 /* switch to large buffer if too big for a small one */
755 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
756 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400757 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400758 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400759 }
760
761 /* now read the rest */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400762 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
763 pdu_length - HEADER_SIZE(server) + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400764 if (length < 0)
765 return length;
766 server->total_read += length;
767
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400768 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400769
770 /*
771 * We know that we received enough to get to the MID as we
772 * checked the pdu_length earlier. Now check to see
773 * if the rest of the header is OK. We borrow the length
774 * var for the rest of the loop to avoid a new stack var.
775 *
776 * 48 bytes is enough to display the header and a little bit
777 * into the payload for debugging purposes.
778 */
Steve French373512e2015-12-18 13:05:30 -0600779 length = server->ops->check_message(buf, server->total_read, server);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400780 if (length != 0)
781 cifs_dump_mem("Bad SMB: ", buf,
782 min_t(unsigned int, server->total_read, 48));
783
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700784 if (server->ops->is_status_pending &&
785 server->ops->is_status_pending(buf, server, length))
786 return -1;
787
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500788 if (!mid)
789 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400790
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400791 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500792 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400793}
794
795static int
Al Viro7c97c202011-06-21 08:51:28 -0400796cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
798 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400799 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400800 unsigned int pdu_length;
801 char *buf = NULL;
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500802 struct task_struct *task_to_wake = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 current->flags |= PF_MEMALLOC;
Joe Perchesf96637b2013-05-04 22:12:25 -0500806 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400807
808 length = atomic_inc_return(&tcpSesAllocCount);
809 if (length > 1)
David Rientjes11d83362015-04-14 15:48:21 -0700810 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700812 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000813 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700814 if (try_to_freeze())
815 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700816
Jeff Layton2a37ef92011-10-19 15:29:23 -0400817 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400818 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700819
Jeff Layton2a37ef92011-10-19 15:29:23 -0400820 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400821 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000822 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000823
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400824 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400825 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000826 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400827 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700828
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400829 /*
830 * The right amount was read from socket - 4 bytes,
831 * so we can now interpret the length field.
832 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400833 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -0700834
Joe Perchesf96637b2013-05-04 22:12:25 -0500835 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400836 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000837 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700838
Jeff Layton89482a52011-10-19 15:28:57 -0400839 /* make sure we have enough to get to the MID */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400840 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500841 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
842 pdu_length);
Jeff Layton89482a52011-10-19 15:28:57 -0400843 cifs_reconnect(server);
844 wake_up(&server->response_q);
845 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700846 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400847
Jeff Layton89482a52011-10-19 15:28:57 -0400848 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400849 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400850 HEADER_SIZE(server) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400851 if (length < 0)
852 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400853 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400854
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400855 mid_entry = server->ops->find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400856
Jeff Layton44d22d82011-10-19 15:29:49 -0400857 if (!mid_entry || !mid_entry->receive)
858 length = standard_receive3(server, mid_entry);
859 else
860 length = mid_entry->receive(server, mid_entry);
861
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400862 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700863 continue;
864
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400865 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -0400866 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700867
Steve Frenchfda35942011-01-20 18:06:34 +0000868 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500869 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400870 if (!mid_entry->multiRsp || mid_entry->multiEnd)
871 mid_entry->callback(mid_entry);
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400872 } else if (!server->ops->is_oplock_break ||
873 !server->ops->is_oplock_break(buf, server)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500874 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
875 atomic_read(&midCount));
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400876 cifs_dump_mem("Received Data is: ", buf,
877 HEADER_SIZE(server));
Steve French39798772006-05-31 22:40:51 +0000878#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400879 if (server->ops->dump_detail)
880 server->ops->dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +0000881 cifs_dump_mids(server);
882#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000883
Steve Frenche4eb2952005-04-28 22:41:09 -0700884 }
885 } /* end while !EXITING */
886
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800887 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400888 cifs_buf_release(server->bigbuf);
889 if (server->smallbuf) /* no sense logging a debug message if NULL */
890 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500892 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400893 clean_demultiplex_info(server);
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500894
895 /* if server->tsk was NULL then wait for a signal before exiting */
896 if (!task_to_wake) {
897 set_current_state(TASK_INTERRUPTIBLE);
898 while (!signal_pending(current)) {
899 schedule();
900 set_current_state(TASK_INTERRUPTIBLE);
901 }
902 set_current_state(TASK_RUNNING);
903 }
904
Jeff Layton0468a2c2008-12-01 07:09:35 -0500905 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
Jeff Laytonc359cf32007-11-16 22:22:06 +0000908/* extract the host portion of the UNC string */
909static char *
910extract_hostname(const char *unc)
911{
912 const char *src;
913 char *dst, *delim;
914 unsigned int len;
915
916 /* skip double chars at beginning of string */
917 /* BB: check validity of these bytes? */
918 src = unc + 2;
919
920 /* delimiter between hostname and sharename is always '\\' now */
921 delim = strchr(src, '\\');
922 if (!delim)
923 return ERR_PTR(-EINVAL);
924
925 len = delim - src;
926 dst = kmalloc((len + 1), GFP_KERNEL);
927 if (dst == NULL)
928 return ERR_PTR(-ENOMEM);
929
930 memcpy(dst, src, len);
931 dst[len] = '\0';
932
933 return dst;
934}
935
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400936static int get_option_ul(substring_t args[], unsigned long *option)
937{
938 int rc;
939 char *string;
940
941 string = match_strdup(args);
942 if (string == NULL)
943 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +0100944 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400945 kfree(string);
946
947 return rc;
948}
949
Eric W. Biederman3da46562013-02-06 01:37:39 -0800950static int get_option_uid(substring_t args[], kuid_t *result)
951{
952 unsigned long value;
953 kuid_t uid;
954 int rc;
955
956 rc = get_option_ul(args, &value);
957 if (rc)
958 return rc;
959
960 uid = make_kuid(current_user_ns(), value);
961 if (!uid_valid(uid))
962 return -EINVAL;
963
964 *result = uid;
965 return 0;
966}
967
968static int get_option_gid(substring_t args[], kgid_t *result)
969{
970 unsigned long value;
971 kgid_t gid;
972 int rc;
973
974 rc = get_option_ul(args, &value);
975 if (rc)
976 return rc;
977
978 gid = make_kgid(current_user_ns(), value);
979 if (!gid_valid(gid))
980 return -EINVAL;
981
982 *result = gid;
983 return 0;
984}
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400985
986static int cifs_parse_security_flavors(char *value,
987 struct smb_vol *vol)
988{
989
990 substring_t args[MAX_OPT_ARGS];
991
Jeff Layton1e3cc572013-06-10 17:12:23 -0500992 /*
993 * With mount options, the last one should win. Reset any existing
994 * settings back to default.
995 */
996 vol->sectype = Unspecified;
997 vol->sign = false;
998
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400999 switch (match_token(value, cifs_secflavor_tokens, args)) {
Jeff Layton3f618222013-06-12 19:52:14 -05001000 case Opt_sec_krb5p:
1001 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1002 return 1;
1003 case Opt_sec_krb5i:
1004 vol->sign = true;
1005 /* Fallthrough */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001006 case Opt_sec_krb5:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001007 vol->sectype = Kerberos;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001008 break;
1009 case Opt_sec_ntlmsspi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001010 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001011 /* Fallthrough */
1012 case Opt_sec_ntlmssp:
1013 vol->sectype = RawNTLMSSP;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001014 break;
1015 case Opt_sec_ntlmi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001016 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001017 /* Fallthrough */
1018 case Opt_ntlm:
1019 vol->sectype = NTLM;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001020 break;
1021 case Opt_sec_ntlmv2i:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001022 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001023 /* Fallthrough */
1024 case Opt_sec_ntlmv2:
1025 vol->sectype = NTLMv2;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001026 break;
1027#ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001029 vol->sectype = LANMAN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001030 break;
1031#endif
1032 case Opt_sec_none:
1033 vol->nullauth = 1;
1034 break;
1035 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001036 cifs_dbg(VFS, "bad security option: %s\n", value);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001037 return 1;
1038 }
1039
1040 return 0;
1041}
1042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043static int
Jeff Layton15b6a472012-05-16 07:50:15 -04001044cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1045{
1046 substring_t args[MAX_OPT_ARGS];
1047
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1052 break;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1056 break;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1060 break;
1061 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001062 cifs_dbg(VFS, "bad cache= option: %s\n", value);
Jeff Layton15b6a472012-05-16 07:50:15 -04001063 return 1;
1064 }
1065 return 0;
1066}
1067
1068static int
Jeff Layton23db65f2012-05-15 12:20:51 -04001069cifs_parse_smb_version(char *value, struct smb_vol *vol)
1070{
1071 substring_t args[MAX_OPT_ARGS];
1072
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1074 case Smb_1:
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1077 break;
Steve French1080ef72011-02-24 18:07:19 +00001078#ifdef CONFIG_CIFS_SMB2
Steve Frenchdd446b12012-11-28 23:21:06 -06001079 case Smb_20:
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001080 vol->ops = &smb20_operations;
Steve Frenchdd446b12012-11-28 23:21:06 -06001081 vol->vals = &smb20_values;
1082 break;
Steve French1080ef72011-02-24 18:07:19 +00001083 case Smb_21:
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1086 break;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001087 case Smb_30:
Steve French38107d42012-12-08 22:08:06 -06001088 vol->ops = &smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001089 vol->vals = &smb30_values;
1090 break;
Steve French20b6d8b2013-06-12 22:48:41 -05001091 case Smb_302:
1092 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1093 vol->vals = &smb302_values;
1094 break;
Steve French5f7fbf72014-12-17 22:52:58 -06001095#ifdef CONFIG_CIFS_SMB311
1096 case Smb_311:
Steve Frenchaab18932015-06-23 23:37:11 -05001097 vol->ops = &smb311_operations;
Steve French5f7fbf72014-12-17 22:52:58 -06001098 vol->vals = &smb311_values;
1099 break;
1100#endif /* SMB311 */
Steve French1080ef72011-02-24 18:07:19 +00001101#endif
Jeff Layton23db65f2012-05-15 12:20:51 -04001102 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001103 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
Jeff Layton23db65f2012-05-15 12:20:51 -04001104 return 1;
1105 }
1106 return 0;
1107}
1108
Jeff Laytond387a5c2012-12-10 06:10:46 -05001109/*
1110 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1111 * fields with the result. Returns 0 on success and an error otherwise.
1112 */
1113static int
1114cifs_parse_devname(const char *devname, struct smb_vol *vol)
1115{
1116 char *pos;
1117 const char *delims = "/\\";
1118 size_t len;
1119
1120 /* make sure we have a valid UNC double delimiter prefix */
1121 len = strspn(devname, delims);
1122 if (len != 2)
1123 return -EINVAL;
1124
1125 /* find delimiter between host and sharename */
1126 pos = strpbrk(devname + 2, delims);
1127 if (!pos)
1128 return -EINVAL;
1129
1130 /* skip past delimiter */
1131 ++pos;
1132
1133 /* now go until next delimiter or end of string */
1134 len = strcspn(pos, delims);
1135
1136 /* move "pos" up to delimiter or NULL */
1137 pos += len;
1138 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1139 if (!vol->UNC)
1140 return -ENOMEM;
1141
1142 convert_delimiter(vol->UNC, '\\');
1143
Sachin Prabhu11e31642016-02-08 13:44:01 +05301144 /* skip any delimiter */
1145 if (*pos == '/' || *pos == '\\')
1146 pos++;
1147
1148 /* If pos is NULL then no prepath */
1149 if (!*pos)
Jeff Laytond387a5c2012-12-10 06:10:46 -05001150 return 0;
1151
1152 vol->prepath = kstrdup(pos, GFP_KERNEL);
1153 if (!vol->prepath)
1154 return -ENOMEM;
1155
1156 return 0;
1157}
1158
Jeff Layton23db65f2012-05-15 12:20:51 -04001159static int
Sean Finneyb9468452011-04-11 13:19:32 +00001160cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001161 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001163 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001164 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 unsigned int temp_len, i, j;
1166 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001167 short int override_uid = -1;
1168 short int override_gid = -1;
1169 bool uid_specified = false;
1170 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001171 bool sloppy = false;
1172 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001173 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001174 char *string = NULL;
1175 char *tmp_end, *value;
1176 char delim;
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001177 bool got_ip = false;
1178 unsigned short port = 0;
1179 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
1181 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001182 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001183 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
Jeff Layton6ee95422012-11-26 11:09:57 -05001185 /* ensure we always start with zeroed-out smb_vol */
1186 memset(vol, 0, sizeof(*vol));
1187
Jeff Layton88463992010-11-22 15:31:03 -05001188 /*
1189 * does not have to be perfect mapping since field is
1190 * informational, only used for servers that do not support
1191 * port 445 and it can be overridden at mount time
1192 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001193 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1194 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001195 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1196
Jeff Layton1397f2e2011-01-07 11:30:28 -05001197 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001198 /* null target name indicates to use *SMBSERVR default called name
1199 if we end up sending RFC1001 session initialize */
1200 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001201 vol->cred_uid = current_uid();
1202 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001203 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001204
Steve French2baa2682014-09-27 02:19:01 -05001205 /*
1206 * default to SFM style remapping of seven reserved characters
1207 * unless user overrides it or we negotiate CIFS POSIX where
1208 * it is unnecessary. Can not simultaneously use more than one mapping
1209 * since then readdir could list files that open could not open
1210 */
1211 vol->remap = true;
1212
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001213 /* default to only allowing write access to owner of the mount */
1214 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
1216 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001217 /* default is always to request posix paths. */
1218 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001219 /* default to using server inode numbers where available */
1220 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001221
Jeff Layton1b359202012-09-19 15:20:27 -07001222 /* default is to use strict cifs caching semantics */
1223 vol->strict_io = true;
1224
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301225 vol->actimeo = CIFS_DEF_ACTIMEO;
1226
Jeff Layton23db65f2012-05-15 12:20:51 -04001227 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1228 vol->ops = &smb1_operations;
1229 vol->vals = &smb1_values;
1230
Rabin Vincentb782fcc2016-07-19 09:25:45 +02001231 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1232
Sean Finneyb9468452011-04-11 13:19:32 +00001233 if (!mountdata)
1234 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Sean Finneyb9468452011-04-11 13:19:32 +00001236 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1237 if (!mountdata_copy)
1238 goto cifs_parse_mount_err;
1239
1240 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001241 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001242
Steve French50c2f752007-07-13 00:33:32 +00001243 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001244 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 separator[0] = options[4];
1246 options += 5;
1247 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001248 cifs_dbg(FYI, "Null separator not allowed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 }
1250 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001251 vol->backupuid_specified = false; /* no backup intent for a user */
1252 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001253
Jeff Layton37d4f992013-05-24 07:40:05 -04001254 switch (cifs_parse_devname(devname, vol)) {
1255 case 0:
1256 break;
1257 case -ENOMEM:
1258 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1259 goto cifs_parse_mount_err;
1260 case -EINVAL:
1261 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1262 goto cifs_parse_mount_err;
1263 default:
1264 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1265 goto cifs_parse_mount_err;
Jeff Laytond387a5c2012-12-10 06:10:46 -05001266 }
1267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001269 substring_t args[MAX_OPT_ARGS];
1270 unsigned long option;
1271 int token;
1272
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 if (!*data)
1274 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001276 token = match_token(data, cifs_mount_option_tokens, args);
1277
1278 switch (token) {
1279
1280 /* Ingnore the following */
1281 case Opt_ignore:
1282 break;
1283
1284 /* Boolean values */
1285 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001287 break;
1288 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001290 break;
1291 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001292 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001293 break;
1294 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001295 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001296 break;
Jeff Layton72bd4812012-10-03 16:02:36 -04001297 case Opt_forcegid:
1298 override_gid = 1;
1299 break;
1300 case Opt_noforcegid:
1301 override_gid = 0;
1302 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001303 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001304 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001305 break;
1306 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001307 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001308 break;
1309 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001311 break;
1312 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001314 break;
1315 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001317 break;
1318 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001320 break;
1321 case Opt_mapchars:
Steve French2baa2682014-09-27 02:19:01 -05001322 vol->sfu_remap = true;
1323 vol->remap = false; /* disable SFM mapping */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001324 break;
1325 case Opt_nomapchars:
Steve French2baa2682014-09-27 02:19:01 -05001326 vol->sfu_remap = false;
1327 break;
1328 case Opt_mapposix:
1329 vol->remap = true;
1330 vol->sfu_remap = false; /* disable SFU mapping */
1331 break;
1332 case Opt_nomapposix:
1333 vol->remap = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001334 break;
1335 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001336 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001337 break;
1338 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001339 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001340 break;
1341 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001342 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001343 break;
1344 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001345 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001346 break;
1347 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001348 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001349 break;
1350 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001351 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001352 break;
1353 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001354 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001355 break;
1356 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001357 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001358 break;
1359 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001360 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001361 /*
1362 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001363 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001364 * local vfs will do advisory
1365 */
Steve French50c2f752007-07-13 00:33:32 +00001366 if (vol->file_mode ==
1367 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001368 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001369 break;
1370 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001371 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001372 break;
1373 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001375 break;
1376 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001378 break;
1379 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001380 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001381 break;
1382 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001383 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001384 break;
1385 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001387 break;
1388 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001390 break;
1391 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001393 break;
1394 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001396 break;
1397 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001398 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001399 break;
1400 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001401 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001402 break;
1403 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001405 break;
1406 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001408 break;
1409 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001410 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001411 break;
1412 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001413 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001414 break;
1415 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001416 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001417 break;
1418 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001420 break;
1421 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001423 break;
1424 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001425 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001426 break;
1427 case Opt_sign:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001428 vol->sign = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001429 break;
1430 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001431 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001432 * is a per tree connection (mount) not a per socket
1433 * or per-smb connection option in the protocol
1434 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1435 */
Steve French95b1cb92008-05-15 16:44:38 +00001436 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001437 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001438 case Opt_noac:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001439 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001440 break;
1441 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301442#ifndef CONFIG_CIFS_FSCACHE
Joe Perchesf96637b2013-05-04 22:12:25 -05001443 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001444 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301445#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301446 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001447 break;
1448 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001449 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001450 break;
1451 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001452 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001453 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001454 case Opt_sloppy:
1455 sloppy = true;
1456 break;
Jeff Laytona0b3df52013-05-24 07:40:59 -04001457 case Opt_nosharesock:
1458 vol->nosharesock = true;
1459 break;
Steve Frenchb2a30772015-09-29 21:49:28 -05001460 case Opt_nopersistent:
1461 vol->nopersistent = true;
1462 if (vol->persistent) {
1463 cifs_dbg(VFS,
1464 "persistenthandles mount options conflict\n");
1465 goto cifs_parse_mount_err;
1466 }
1467 break;
1468 case Opt_persistent:
1469 vol->persistent = true;
Steve French592fafe2015-11-03 10:08:53 -06001470 if ((vol->nopersistent) || (vol->resilient)) {
Steve Frenchb2a30772015-09-29 21:49:28 -05001471 cifs_dbg(VFS,
1472 "persistenthandles mount options conflict\n");
1473 goto cifs_parse_mount_err;
1474 }
1475 break;
Steve French592fafe2015-11-03 10:08:53 -06001476 case Opt_resilient:
1477 vol->resilient = true;
1478 if (vol->persistent) {
1479 cifs_dbg(VFS,
1480 "persistenthandles mount options conflict\n");
1481 goto cifs_parse_mount_err;
1482 }
1483 break;
1484 case Opt_noresilient:
1485 vol->resilient = false; /* already the default */
1486 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001487
1488 /* Numeric Values */
1489 case Opt_backupuid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001490 if (get_option_uid(args, &vol->backupuid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001491 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1492 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001493 goto cifs_parse_mount_err;
1494 }
1495 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001496 break;
1497 case Opt_backupgid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001498 if (get_option_gid(args, &vol->backupgid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001499 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1500 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001501 goto cifs_parse_mount_err;
1502 }
1503 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001504 break;
1505 case Opt_uid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001506 if (get_option_uid(args, &vol->linux_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001507 cifs_dbg(VFS, "%s: Invalid uid value\n",
1508 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001509 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001511 uid_specified = true;
1512 break;
1513 case Opt_cruid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001514 if (get_option_uid(args, &vol->cred_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001515 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1516 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001517 goto cifs_parse_mount_err;
1518 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001519 break;
1520 case Opt_gid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001521 if (get_option_gid(args, &vol->linux_gid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001522 cifs_dbg(VFS, "%s: Invalid gid value\n",
1523 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001524 goto cifs_parse_mount_err;
1525 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001526 gid_specified = true;
1527 break;
1528 case Opt_file_mode:
1529 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001530 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1531 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001532 goto cifs_parse_mount_err;
1533 }
1534 vol->file_mode = option;
1535 break;
1536 case Opt_dirmode:
1537 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001538 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1539 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001540 goto cifs_parse_mount_err;
1541 }
1542 vol->dir_mode = option;
1543 break;
1544 case Opt_port:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001545 if (get_option_ul(args, &option) ||
1546 option > USHRT_MAX) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001547 cifs_dbg(VFS, "%s: Invalid port value\n",
1548 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001549 goto cifs_parse_mount_err;
1550 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001551 port = (unsigned short)option;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001552 break;
1553 case Opt_rsize:
1554 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001555 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1556 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001557 goto cifs_parse_mount_err;
1558 }
1559 vol->rsize = option;
1560 break;
1561 case Opt_wsize:
1562 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001563 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1564 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001565 goto cifs_parse_mount_err;
1566 }
1567 vol->wsize = option;
1568 break;
1569 case Opt_actimeo:
1570 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001571 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1572 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001573 goto cifs_parse_mount_err;
1574 }
1575 vol->actimeo = HZ * option;
1576 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001577 cifs_dbg(VFS, "attribute cache timeout too large\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001578 goto cifs_parse_mount_err;
1579 }
1580 break;
Steve Frenchadfeb3e2015-12-18 12:31:36 -06001581 case Opt_echo_interval:
1582 if (get_option_ul(args, &option)) {
1583 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1584 __func__);
1585 goto cifs_parse_mount_err;
1586 }
1587 vol->echo_interval = option;
1588 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001589
1590 /* String Arguments */
1591
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001592 case Opt_blank_user:
1593 /* null user, ie. anonymous authentication */
1594 vol->nullauth = 1;
1595 vol->username = NULL;
1596 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001597 case Opt_user:
1598 string = match_strdup(args);
1599 if (string == NULL)
1600 goto out_nomem;
1601
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04001602 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1603 CIFS_MAX_USERNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001604 pr_warn("CIFS: username too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001605 goto cifs_parse_mount_err;
1606 }
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001607
1608 kfree(vol->username);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001609 vol->username = kstrdup(string, GFP_KERNEL);
Joe Perchesf96637b2013-05-04 22:12:25 -05001610 if (!vol->username)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001611 goto cifs_parse_mount_err;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001612 break;
1613 case Opt_blank_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001614 /* passwords have to be handled differently
1615 * to allow the character used for deliminator
1616 * to be passed within them
1617 */
1618
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001619 /*
1620 * Check if this is a case where the password
1621 * starts with a delimiter
1622 */
1623 tmp_end = strchr(data, '=');
1624 tmp_end++;
1625 if (!(tmp_end < end && tmp_end[1] == delim)) {
1626 /* No it is not. Set the password to NULL */
Namjae Jeond6ccf492014-08-21 19:11:20 +09001627 kfree(vol->password);
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001628 vol->password = NULL;
1629 break;
1630 }
1631 /* Yes it is. Drop down to Opt_pass below.*/
1632 case Opt_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001633 /* Obtain the value string */
1634 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001635 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001636
1637 /* Set tmp_end to end of the string */
1638 tmp_end = (char *) value + strlen(value);
1639
1640 /* Check if following character is the deliminator
1641 * If yes, we have encountered a double deliminator
1642 * reset the NULL character to the deliminator
1643 */
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301644 if (tmp_end < end && tmp_end[1] == delim) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001645 tmp_end[0] = delim;
1646
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301647 /* Keep iterating until we get to a single
1648 * deliminator OR the end
1649 */
1650 while ((tmp_end = strchr(tmp_end, delim))
1651 != NULL && (tmp_end[1] == delim)) {
1652 tmp_end = (char *) &tmp_end[2];
1653 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001654
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301655 /* Reset var options to point to next element */
1656 if (tmp_end) {
1657 tmp_end[0] = '\0';
1658 options = (char *) &tmp_end[1];
1659 } else
1660 /* Reached the end of the mount option
1661 * string */
1662 options = end;
1663 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001664
Namjae Jeond6ccf492014-08-21 19:11:20 +09001665 kfree(vol->password);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001666 /* Now build new password string */
1667 temp_len = strlen(value);
1668 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1669 if (vol->password == NULL) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001670 pr_warn("CIFS: no memory for password\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001671 goto cifs_parse_mount_err;
1672 }
1673
1674 for (i = 0, j = 0; i < temp_len; i++, j++) {
1675 vol->password[j] = value[i];
1676 if ((value[i] == delim) &&
1677 value[i+1] == delim)
1678 /* skip the second deliminator */
1679 i++;
1680 }
1681 vol->password[j] = '\0';
1682 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001683 case Opt_blank_ip:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001684 /* FIXME: should this be an error instead? */
1685 got_ip = false;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001686 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001687 case Opt_ip:
1688 string = match_strdup(args);
1689 if (string == NULL)
1690 goto out_nomem;
1691
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001692 if (!cifs_convert_address(dstaddr, string,
1693 strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001694 pr_err("CIFS: bad ip= option (%s).\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001695 goto cifs_parse_mount_err;
1696 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001697 got_ip = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001698 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001699 case Opt_domain:
1700 string = match_strdup(args);
1701 if (string == NULL)
1702 goto out_nomem;
1703
Chen Gang057d6332013-07-19 09:01:36 +08001704 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1705 == CIFS_MAX_DOMAINNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001706 pr_warn("CIFS: domain name too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001707 goto cifs_parse_mount_err;
1708 }
1709
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001710 kfree(vol->domainname);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001711 vol->domainname = kstrdup(string, GFP_KERNEL);
1712 if (!vol->domainname) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001713 pr_warn("CIFS: no memory for domainname\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001714 goto cifs_parse_mount_err;
1715 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001716 cifs_dbg(FYI, "Domain name set\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001717 break;
1718 case Opt_srcaddr:
1719 string = match_strdup(args);
1720 if (string == NULL)
1721 goto out_nomem;
1722
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001723 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001724 (struct sockaddr *)&vol->srcaddr,
1725 string, strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001726 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1727 string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001728 goto cifs_parse_mount_err;
1729 }
1730 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001731 case Opt_iocharset:
1732 string = match_strdup(args);
1733 if (string == NULL)
1734 goto out_nomem;
1735
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001736 if (strnlen(string, 1024) >= 65) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001737 pr_warn("CIFS: iocharset name too long.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001738 goto cifs_parse_mount_err;
1739 }
1740
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001741 if (strncasecmp(string, "default", 7) != 0) {
Taesoo Kim2bd50fb2015-03-21 19:08:30 -04001742 kfree(vol->iocharset);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001743 vol->iocharset = kstrdup(string,
1744 GFP_KERNEL);
1745 if (!vol->iocharset) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001746 pr_warn("CIFS: no memory for charset\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001747 goto cifs_parse_mount_err;
1748 }
1749 }
1750 /* if iocharset not set then load_nls_default
1751 * is used by caller
1752 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001753 cifs_dbg(FYI, "iocharset set to %s\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001754 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001755 case Opt_netbiosname:
1756 string = match_strdup(args);
1757 if (string == NULL)
1758 goto out_nomem;
1759
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001760 memset(vol->source_rfc1001_name, 0x20,
1761 RFC1001_NAME_LEN);
1762 /*
1763 * FIXME: are there cases in which a comma can
1764 * be valid in workstation netbios name (and
1765 * need special handling)?
1766 */
1767 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1768 /* don't ucase netbiosname for user */
1769 if (string[i] == 0)
1770 break;
1771 vol->source_rfc1001_name[i] = string[i];
1772 }
1773 /* The string has 16th byte zero still from
1774 * set at top of the function
1775 */
1776 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001777 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001778 break;
1779 case Opt_servern:
1780 /* servernetbiosname specified override *SMBSERVER */
1781 string = match_strdup(args);
1782 if (string == NULL)
1783 goto out_nomem;
1784
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001785 /* last byte, type, is 0x20 for servr type */
1786 memset(vol->target_rfc1001_name, 0x20,
1787 RFC1001_NAME_LEN_WITH_NULL);
1788
1789 /* BB are there cases in which a comma can be
1790 valid in this workstation netbios name
1791 (and need special handling)? */
1792
1793 /* user or mount helper must uppercase the
1794 netbios name */
1795 for (i = 0; i < 15; i++) {
1796 if (string[i] == 0)
1797 break;
1798 vol->target_rfc1001_name[i] = string[i];
1799 }
1800 /* The string has 16th byte zero still from
1801 set at top of the function */
1802 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001803 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001804 break;
1805 case Opt_ver:
1806 string = match_strdup(args);
1807 if (string == NULL)
1808 goto out_nomem;
1809
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001810 if (strncasecmp(string, "1", 1) == 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001811 /* This is the default */
1812 break;
1813 }
1814 /* For all other value, error */
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001815 pr_warn("CIFS: Invalid version specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001816 goto cifs_parse_mount_err;
Jeff Layton23db65f2012-05-15 12:20:51 -04001817 case Opt_vers:
1818 string = match_strdup(args);
1819 if (string == NULL)
1820 goto out_nomem;
1821
1822 if (cifs_parse_smb_version(string, vol) != 0)
1823 goto cifs_parse_mount_err;
1824 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001825 case Opt_sec:
1826 string = match_strdup(args);
1827 if (string == NULL)
1828 goto out_nomem;
1829
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001830 if (cifs_parse_security_flavors(string, vol) != 0)
1831 goto cifs_parse_mount_err;
1832 break;
Jeff Layton15b6a472012-05-16 07:50:15 -04001833 case Opt_cache:
1834 string = match_strdup(args);
1835 if (string == NULL)
1836 goto out_nomem;
1837
1838 if (cifs_parse_cache_flavor(string, vol) != 0)
1839 goto cifs_parse_mount_err;
1840 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001841 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001842 /*
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;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001848 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001850 /* Free up any allocated string */
1851 kfree(string);
1852 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001854
Jeff Laytond8162552012-03-23 14:40:56 -04001855 if (!sloppy && invalid) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001856 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
Jeff Laytond8162552012-03-23 14:40:56 -04001857 goto cifs_parse_mount_err;
1858 }
1859
Jeff Layton8a8798a2012-01-17 16:09:15 -05001860#ifndef CONFIG_KEYS
1861 /* Muliuser mounts require CONFIG_KEYS support */
1862 if (vol->multiuser) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001863 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001864 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001865 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001866#endif
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001867 if (!vol->UNC) {
Jeff Layton37d4f992013-05-24 07:40:05 -04001868 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001869 goto cifs_parse_mount_err;
1870 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001871
Jeff Layton62a1a432012-12-10 06:10:45 -05001872 /* make sure UNC has a share name */
1873 if (!strchr(vol->UNC + 3, '\\')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001874 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
Jeff Layton62a1a432012-12-10 06:10:45 -05001875 goto cifs_parse_mount_err;
1876 }
1877
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001878 if (!got_ip) {
1879 /* No ip= option specified? Try to get it from UNC */
1880 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1881 strlen(&vol->UNC[2]))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001882 pr_err("Unable to determine destination address.\n");
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001883 goto cifs_parse_mount_err;
1884 }
1885 }
1886
1887 /* set the port that we got earlier */
1888 cifs_set_port(dstaddr, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001890 if (uid_specified)
1891 vol->override_uid = override_uid;
1892 else if (override_uid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001893 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001894
1895 if (gid_specified)
1896 vol->override_gid = override_gid;
1897 else if (override_gid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001898 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001899
Sean Finneyb9468452011-04-11 13:19:32 +00001900 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001902
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001903out_nomem:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001904 pr_warn("Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001905cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001906 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001907 kfree(mountdata_copy);
1908 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909}
1910
Ben Greear3eb9a882010-09-01 17:06:02 -07001911/** Returns true if srcaddr isn't specified and rhs isn't
1912 * specified, or if srcaddr is specified and
1913 * matches the IP address of the rhs argument.
1914 */
Jeff Layton45151482010-07-06 20:43:02 -04001915static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001916srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1917{
1918 switch (srcaddr->sa_family) {
1919 case AF_UNSPEC:
1920 return (rhs->sa_family == AF_UNSPEC);
1921 case AF_INET: {
1922 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1923 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1924 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1925 }
1926 case AF_INET6: {
1927 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
Nickolai Zeldoviche3e27752013-01-16 21:36:17 -05001928 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
Ben Greear3eb9a882010-09-01 17:06:02 -07001929 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1930 }
1931 default:
1932 WARN_ON(1);
1933 return false; /* don't expect to be here */
1934 }
1935}
1936
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001937/*
1938 * If no port is specified in addr structure, we try to match with 445 port
1939 * and if it fails - with 139 ports. It should be called only if address
1940 * families of server and addr are equal.
1941 */
1942static bool
1943match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1944{
Steve French6da97912011-03-13 18:55:55 +00001945 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001946
1947 switch (addr->sa_family) {
1948 case AF_INET:
1949 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1950 port = ((struct sockaddr_in *) addr)->sin_port;
1951 break;
1952 case AF_INET6:
1953 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1954 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1955 break;
1956 default:
1957 WARN_ON(1);
1958 return false;
1959 }
1960
1961 if (!port) {
1962 port = htons(CIFS_PORT);
1963 if (port == *sport)
1964 return true;
1965
1966 port = htons(RFC1001_PORT);
1967 }
1968
1969 return port == *sport;
1970}
Ben Greear3eb9a882010-09-01 17:06:02 -07001971
1972static bool
1973match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1974 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975{
Jeff Layton45151482010-07-06 20:43:02 -04001976 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001977 case AF_INET: {
1978 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1979 struct sockaddr_in *srv_addr4 =
1980 (struct sockaddr_in *)&server->dstaddr;
1981
1982 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001983 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001984 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001985 }
1986 case AF_INET6: {
1987 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1988 struct sockaddr_in6 *srv_addr6 =
1989 (struct sockaddr_in6 *)&server->dstaddr;
1990
Jeff Layton45151482010-07-06 20:43:02 -04001991 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001992 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001993 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001994 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001995 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001996 break;
1997 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001998 default:
1999 WARN_ON(1);
2000 return false; /* don't expect to be here */
2001 }
Jeff Layton45151482010-07-06 20:43:02 -04002002
Ben Greear3eb9a882010-09-01 17:06:02 -07002003 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2004 return false;
2005
Jeff Layton45151482010-07-06 20:43:02 -04002006 return true;
2007}
2008
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002009static bool
2010match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2011{
Jeff Layton3f618222013-06-12 19:52:14 -05002012 /*
2013 * The select_sectype function should either return the vol->sectype
2014 * that was specified, or "Unspecified" if that sectype was not
2015 * compatible with the given NEGOTIATE request.
2016 */
2017 if (select_sectype(server, vol->sectype) == Unspecified)
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002018 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002019
Jeff Layton3f618222013-06-12 19:52:14 -05002020 /*
2021 * Now check if signing mode is acceptable. No need to check
2022 * global_secflags at this point since if MUST_SIGN is set then
2023 * the server->sign had better be too.
2024 */
Jeff Layton38d77c52013-05-26 07:01:00 -04002025 if (vol->sign && !server->sign)
2026 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002027
2028 return true;
2029}
2030
Jeff Layton9fa114f2012-11-26 11:09:57 -05002031static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002032{
Jeff Layton9fa114f2012-11-26 11:09:57 -05002033 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2034
Jeff Laytona0b3df52013-05-24 07:40:59 -04002035 if (vol->nosharesock)
2036 return 0;
2037
Jeff Layton23db65f2012-05-15 12:20:51 -04002038 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2039 return 0;
2040
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002041 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2042 return 0;
2043
2044 if (!match_address(server, addr,
2045 (struct sockaddr *)&vol->srcaddr))
2046 return 0;
2047
2048 if (!match_port(server, addr))
2049 return 0;
2050
2051 if (!match_security(server, vol))
2052 return 0;
2053
Rabin Vincentb782fcc2016-07-19 09:25:45 +02002054 if (server->echo_interval != vol->echo_interval * HZ)
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002055 return 0;
2056
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002057 return 1;
2058}
2059
Jeff Layton45151482010-07-06 20:43:02 -04002060static struct TCP_Server_Info *
Jeff Layton9fa114f2012-11-26 11:09:57 -05002061cifs_find_tcp_session(struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002062{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002063 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302065 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002066 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Jeff Layton9fa114f2012-11-26 11:09:57 -05002067 if (!match_server(server, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002068 continue;
2069
Jeff Laytone7ddee92008-11-14 13:44:38 -05002070 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302071 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesf96637b2013-05-04 22:12:25 -05002072 cifs_dbg(FYI, "Existing tcp session with server found\n");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002073 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302075 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 return NULL;
2077}
2078
Jeff Layton14fbf502008-11-14 13:53:46 -05002079static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002080cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081{
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002082 struct task_struct *task;
2083
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302084 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002085 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302086 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002087 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 }
Steve Frenchdea570e02008-05-06 22:05:51 +00002089
Rob Landleyf1d0c992011-01-22 15:44:05 -06002090 put_net(cifs_net_ns(server));
2091
Jeff Laytone7ddee92008-11-14 13:44:38 -05002092 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302093 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002094
Jeff Laytonc74093b2011-01-11 07:24:23 -05002095 cancel_delayed_work_sync(&server->echo);
2096
Jeff Laytone7ddee92008-11-14 13:44:38 -05002097 spin_lock(&GlobalMid_Lock);
2098 server->tcpStatus = CifsExiting;
2099 spin_unlock(&GlobalMid_Lock);
2100
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002101 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302102 cifs_fscache_release_client_cookie(server);
2103
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002104 kfree(server->session_key.response);
2105 server->session_key.response = NULL;
2106 server->session_key.len = 0;
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002107
2108 task = xchg(&server->tsk, NULL);
2109 if (task)
2110 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111}
2112
Jeff Layton63c038c2008-12-01 18:41:46 -05002113static struct TCP_Server_Info *
2114cifs_get_tcp_session(struct smb_vol *volume_info)
2115{
2116 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Layton63c038c2008-12-01 18:41:46 -05002117 int rc;
2118
Joe Perchesf96637b2013-05-04 22:12:25 -05002119 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
Jeff Layton63c038c2008-12-01 18:41:46 -05002120
2121 /* see if we already have a matching tcp_ses */
Jeff Layton9fa114f2012-11-26 11:09:57 -05002122 tcp_ses = cifs_find_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002123 if (tcp_ses)
2124 return tcp_ses;
2125
2126 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2127 if (!tcp_ses) {
2128 rc = -ENOMEM;
2129 goto out_err;
2130 }
2131
Jeff Layton23db65f2012-05-15 12:20:51 -04002132 tcp_ses->ops = volume_info->ops;
2133 tcp_ses->vals = volume_info->vals;
Rob Landleyf1d0c992011-01-22 15:44:05 -06002134 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002135 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2136 if (IS_ERR(tcp_ses->hostname)) {
2137 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002138 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002139 }
2140
2141 tcp_ses->noblocksnd = volume_info->noblocksnd;
2142 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002143 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002144 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002145 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002146 init_waitqueue_head(&tcp_ses->response_q);
2147 init_waitqueue_head(&tcp_ses->request_q);
2148 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2149 mutex_init(&tcp_ses->srv_mutex);
2150 memcpy(tcp_ses->workstation_RFC1001_name,
2151 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2152 memcpy(tcp_ses->server_RFC1001_name,
2153 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002154 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002155 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002156 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002157 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002158 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2159 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002160 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton9fa114f2012-11-26 11:09:57 -05002161 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2162 sizeof(tcp_ses->srcaddr));
2163 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2164 sizeof(tcp_ses->dstaddr));
Sachin Prabhu39552ea2014-05-13 00:48:12 +01002165#ifdef CONFIG_CIFS_SMB2
2166 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2167#endif
Jeff Layton63c038c2008-12-01 18:41:46 -05002168 /*
2169 * at this point we are the only ones with the pointer
2170 * to the struct since the kernel thread not created yet
2171 * no need to spinlock this init of tcpStatus or srv_count
2172 */
2173 tcp_ses->tcpStatus = CifsNew;
2174 ++tcp_ses->srv_count;
2175
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002176 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2177 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2178 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2179 else
2180 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2181
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002182 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002183 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002184 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002185 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002186 }
2187
2188 /*
2189 * since we're in a cifs function already, we know that
2190 * this will succeed. No need for try_module_get().
2191 */
2192 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002193 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002194 tcp_ses, "cifsd");
2195 if (IS_ERR(tcp_ses->tsk)) {
2196 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesf96637b2013-05-04 22:12:25 -05002197 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002198 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002199 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002200 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002201 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002202
2203 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302204 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002205 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302206 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002207
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302208 cifs_fscache_get_client_cookie(tcp_ses);
2209
Jeff Laytonc74093b2011-01-11 07:24:23 -05002210 /* queue echo request delayed work */
Steve Frenchadfeb3e2015-12-18 12:31:36 -06002211 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002212
Jeff Layton63c038c2008-12-01 18:41:46 -05002213 return tcp_ses;
2214
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002215out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002216 cifs_crypto_shash_release(tcp_ses);
2217
Rob Landleyf1d0c992011-01-22 15:44:05 -06002218 put_net(cifs_net_ns(tcp_ses));
2219
Jeff Layton63c038c2008-12-01 18:41:46 -05002220out_err:
2221 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00002222 if (!IS_ERR(tcp_ses->hostname))
2223 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002224 if (tcp_ses->ssocket)
2225 sock_release(tcp_ses->ssocket);
2226 kfree(tcp_ses);
2227 }
2228 return ERR_PTR(rc);
2229}
2230
Steve French96daf2b2011-05-27 04:34:02 +00002231static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002232{
Jeff Layton3f618222013-06-12 19:52:14 -05002233 if (vol->sectype != Unspecified &&
2234 vol->sectype != ses->sectype)
2235 return 0;
2236
2237 switch (ses->sectype) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002238 case Kerberos:
Eric W. Biederman64ed39d2013-02-06 02:30:39 -08002239 if (!uid_eq(vol->cred_uid, ses->cred_uid))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002240 return 0;
2241 break;
2242 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002243 /* NULL username means anonymous session */
2244 if (ses->user_name == NULL) {
2245 if (!vol->nullauth)
2246 return 0;
2247 break;
2248 }
2249
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002250 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002251 if (strncmp(ses->user_name,
2252 vol->username ? vol->username : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002253 CIFS_MAX_USERNAME_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002254 return 0;
Jeff Layton08b37d52014-05-23 06:53:10 -04002255 if ((vol->username && strlen(vol->username) != 0) &&
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002256 ses->password != NULL &&
2257 strncmp(ses->password,
2258 vol->password ? vol->password : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002259 CIFS_MAX_PASSWORD_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002260 return 0;
2261 }
2262 return 1;
2263}
2264
Steve French96daf2b2011-05-27 04:34:02 +00002265static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002266cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267{
Steve French96daf2b2011-05-27 04:34:02 +00002268 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302270 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002271 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002272 if (ses->status == CifsExiting)
2273 continue;
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002274 if (!match_session(ses, vol))
2275 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002276 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302277 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002278 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302280 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 return NULL;
2282}
2283
Jeff Layton14fbf502008-11-14 13:53:46 -05002284static void
Steve French96daf2b2011-05-27 04:34:02 +00002285cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002286{
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002287 unsigned int rc, xid;
Jeff Layton14fbf502008-11-14 13:53:46 -05002288 struct TCP_Server_Info *server = ses->server;
2289
Joe Perchesf96637b2013-05-04 22:12:25 -05002290 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002291
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302292 spin_lock(&cifs_tcp_ses_lock);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002293 if (ses->status == CifsExiting) {
2294 spin_unlock(&cifs_tcp_ses_lock);
2295 return;
2296 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002297 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302298 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002299 return;
2300 }
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002301 if (ses->status == CifsGood)
2302 ses->status = CifsExiting;
2303 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002304
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002305 if (ses->status == CifsExiting && server->ops->logoff) {
2306 xid = get_xid();
2307 rc = server->ops->logoff(xid, ses);
2308 if (rc)
2309 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2310 __func__, rc);
2311 _free_xid(xid);
2312 }
2313
2314 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002315 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302316 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002317
Jeff Layton14fbf502008-11-14 13:53:46 -05002318 sesInfoFree(ses);
2319 cifs_put_tcp_session(server);
2320}
2321
Jeff Layton8a8798a2012-01-17 16:09:15 -05002322#ifdef CONFIG_KEYS
2323
Chen Gang057d6332013-07-19 09:01:36 +08002324/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2325#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
Jeff Layton8a8798a2012-01-17 16:09:15 -05002326
2327/* Populate username and pw fields from keyring if possible */
2328static int
2329cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2330{
2331 int rc = 0;
David Howells146aa8b2015-10-21 14:04:48 +01002332 const char *delim, *payload;
2333 char *desc;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002334 ssize_t len;
2335 struct key *key;
2336 struct TCP_Server_Info *server = ses->server;
2337 struct sockaddr_in *sa;
2338 struct sockaddr_in6 *sa6;
David Howells146aa8b2015-10-21 14:04:48 +01002339 const struct user_key_payload *upayload;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002340
2341 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2342 if (!desc)
2343 return -ENOMEM;
2344
2345 /* try to find an address key first */
2346 switch (server->dstaddr.ss_family) {
2347 case AF_INET:
2348 sa = (struct sockaddr_in *)&server->dstaddr;
2349 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2350 break;
2351 case AF_INET6:
2352 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2353 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2354 break;
2355 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05002356 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2357 server->dstaddr.ss_family);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002358 rc = -EINVAL;
2359 goto out_err;
2360 }
2361
Joe Perchesf96637b2013-05-04 22:12:25 -05002362 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002363 key = request_key(&key_type_logon, desc, "");
2364 if (IS_ERR(key)) {
2365 if (!ses->domainName) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002366 cifs_dbg(FYI, "domainName is NULL\n");
Jeff Layton8a8798a2012-01-17 16:09:15 -05002367 rc = PTR_ERR(key);
2368 goto out_err;
2369 }
2370
2371 /* didn't work, try to find a domain key */
2372 sprintf(desc, "cifs:d:%s", ses->domainName);
Joe Perchesf96637b2013-05-04 22:12:25 -05002373 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002374 key = request_key(&key_type_logon, desc, "");
2375 if (IS_ERR(key)) {
2376 rc = PTR_ERR(key);
2377 goto out_err;
2378 }
2379 }
2380
2381 down_read(&key->sem);
David Howells146aa8b2015-10-21 14:04:48 +01002382 upayload = user_key_payload(key);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002383 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002384 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002385 goto out_key_put;
2386 }
2387
2388 /* find first : in payload */
David Howells146aa8b2015-10-21 14:04:48 +01002389 payload = upayload->data;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002390 delim = strnchr(payload, upayload->datalen, ':');
Joe Perchesf96637b2013-05-04 22:12:25 -05002391 cifs_dbg(FYI, "payload=%s\n", payload);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002392 if (!delim) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002393 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2394 upayload->datalen);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002395 rc = -EINVAL;
2396 goto out_key_put;
2397 }
2398
2399 len = delim - payload;
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002400 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002401 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2402 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002403 rc = -EINVAL;
2404 goto out_key_put;
2405 }
2406
2407 vol->username = kstrndup(payload, len, GFP_KERNEL);
2408 if (!vol->username) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002409 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2410 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002411 rc = -ENOMEM;
2412 goto out_key_put;
2413 }
Joe Perchesf96637b2013-05-04 22:12:25 -05002414 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002415
2416 len = key->datalen - (len + 1);
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002417 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002418 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002419 rc = -EINVAL;
2420 kfree(vol->username);
2421 vol->username = NULL;
2422 goto out_key_put;
2423 }
2424
2425 ++delim;
2426 vol->password = kstrndup(delim, len, GFP_KERNEL);
2427 if (!vol->password) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002428 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2429 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002430 rc = -ENOMEM;
2431 kfree(vol->username);
2432 vol->username = NULL;
2433 goto out_key_put;
2434 }
2435
2436out_key_put:
2437 up_read(&key->sem);
2438 key_put(key);
2439out_err:
2440 kfree(desc);
Joe Perchesf96637b2013-05-04 22:12:25 -05002441 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002442 return rc;
2443}
2444#else /* ! CONFIG_KEYS */
2445static inline int
2446cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2447 struct cifs_ses *ses __attribute__((unused)))
2448{
2449 return -ENOSYS;
2450}
2451#endif /* CONFIG_KEYS */
2452
Steve French96daf2b2011-05-27 04:34:02 +00002453static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002454cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2455{
Pavel Shilovsky286170a2012-05-25 10:43:58 +04002456 int rc = -ENOMEM;
2457 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002458 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002459 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2460 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002461
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002462 xid = get_xid();
Jeff Layton36988c72010-04-24 07:57:43 -04002463
Jeff Layton4ff67b72010-07-06 20:43:02 -04002464 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002465 if (ses) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002466 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2467 ses->status);
Jeff Layton36988c72010-04-24 07:57:43 -04002468
Jeff Layton36988c72010-04-24 07:57:43 -04002469 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002470 rc = cifs_negotiate_protocol(xid, ses);
2471 if (rc) {
2472 mutex_unlock(&ses->session_mutex);
2473 /* problem -- put our ses reference */
2474 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002475 free_xid(xid);
Jeff Layton198b5682010-04-24 07:57:48 -04002476 return ERR_PTR(rc);
2477 }
Jeff Layton36988c72010-04-24 07:57:43 -04002478 if (ses->need_reconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002479 cifs_dbg(FYI, "Session needs reconnect\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002480 rc = cifs_setup_session(xid, ses,
2481 volume_info->local_nls);
2482 if (rc) {
2483 mutex_unlock(&ses->session_mutex);
2484 /* problem -- put our reference */
2485 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002486 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002487 return ERR_PTR(rc);
2488 }
2489 }
2490 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002491
2492 /* existing SMB ses has a server reference already */
2493 cifs_put_tcp_session(server);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002494 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002495 return ses;
2496 }
2497
Joe Perchesf96637b2013-05-04 22:12:25 -05002498 cifs_dbg(FYI, "Existing smb sess not found\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002499 ses = sesInfoAlloc();
2500 if (ses == NULL)
2501 goto get_ses_fail;
2502
2503 /* new SMB session uses our server ref */
2504 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002505 if (server->dstaddr.ss_family == AF_INET6)
2506 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002507 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002508 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002509
Steve French8727c8a2011-02-25 01:11:56 -06002510 if (volume_info->username) {
2511 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2512 if (!ses->user_name)
2513 goto get_ses_fail;
2514 }
Jeff Layton36988c72010-04-24 07:57:43 -04002515
2516 /* volume_info->password freed at unmount */
2517 if (volume_info->password) {
2518 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2519 if (!ses->password)
2520 goto get_ses_fail;
2521 }
2522 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002523 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2524 if (!ses->domainName)
2525 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002526 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002527 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002528 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002529
Jeff Layton28e11bd2013-05-26 07:01:00 -04002530 ses->sectype = volume_info->sectype;
2531 ses->sign = volume_info->sign;
Jeff Layton36988c72010-04-24 07:57:43 -04002532
2533 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002534 rc = cifs_negotiate_protocol(xid, ses);
2535 if (!rc)
2536 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002537 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002538 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002539 goto get_ses_fail;
2540
2541 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302542 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002543 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302544 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002545
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002546 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002547 return ses;
2548
2549get_ses_fail:
2550 sesInfoFree(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002551 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002552 return ERR_PTR(rc);
2553}
2554
Steve French96daf2b2011-05-27 04:34:02 +00002555static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002556{
2557 if (tcon->tidStatus == CifsExiting)
2558 return 0;
2559 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2560 return 0;
2561 return 1;
2562}
2563
Steve French96daf2b2011-05-27 04:34:02 +00002564static struct cifs_tcon *
2565cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566{
2567 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002568 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302570 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002571 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002572 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002573 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002574 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002575 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302576 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 return tcon;
2578 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302579 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 return NULL;
2581}
2582
Jeff Laytonf1987b42008-11-15 11:12:47 -05002583static void
Steve French96daf2b2011-05-27 04:34:02 +00002584cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002585{
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002586 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002587 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002588
Joe Perchesf96637b2013-05-04 22:12:25 -05002589 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302590 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002591 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302592 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002593 return;
2594 }
2595
2596 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302597 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002598
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002599 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002600 if (ses->server->ops->tree_disconnect)
2601 ses->server->ops->tree_disconnect(xid, tcon);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002602 _free_xid(xid);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002603
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302604 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002605 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002606 cifs_put_smb_ses(ses);
2607}
2608
Steve French96daf2b2011-05-27 04:34:02 +00002609static struct cifs_tcon *
2610cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002611{
2612 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002613 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002614
2615 tcon = cifs_find_tcon(ses, volume_info->UNC);
2616 if (tcon) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002617 cifs_dbg(FYI, "Found match on UNC path\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002618 /* existing tcon already has a reference */
2619 cifs_put_smb_ses(ses);
2620 if (tcon->seal != volume_info->seal)
Joe Perchesf96637b2013-05-04 22:12:25 -05002621 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002622 return tcon;
2623 }
2624
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002625 if (!ses->server->ops->tree_connect) {
2626 rc = -ENOSYS;
2627 goto out_fail;
2628 }
2629
Jeff Laytond00c28d2010-04-24 07:57:44 -04002630 tcon = tconInfoAlloc();
2631 if (tcon == NULL) {
2632 rc = -ENOMEM;
2633 goto out_fail;
2634 }
2635
2636 tcon->ses = ses;
2637 if (volume_info->password) {
2638 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2639 if (!tcon->password) {
2640 rc = -ENOMEM;
2641 goto out_fail;
2642 }
2643 }
2644
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002645 /*
2646 * BB Do we need to wrap session_mutex around this TCon call and Unix
2647 * SetFS as we do on SessSetup and reconnect?
2648 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002649 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002650 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2651 volume_info->local_nls);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002652 free_xid(xid);
Joe Perchesf96637b2013-05-04 22:12:25 -05002653 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002654 if (rc)
2655 goto out_fail;
2656
2657 if (volume_info->nodfs) {
2658 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002659 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002660 }
2661 tcon->seal = volume_info->seal;
Steve Frenchb618f002015-11-03 09:15:03 -06002662 tcon->use_persistent = false;
2663 /* check if SMB2 or later, CIFS does not support persistent handles */
2664 if (volume_info->persistent) {
2665 if (ses->server->vals->protocol_id == 0) {
2666 cifs_dbg(VFS,
2667 "SMB3 or later required for persistent handles\n");
2668 rc = -EOPNOTSUPP;
2669 goto out_fail;
Steve French592fafe2015-11-03 10:08:53 -06002670#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06002671 } else if (ses->server->capabilities &
2672 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2673 tcon->use_persistent = true;
2674 else /* persistent handles requested but not supported */ {
2675 cifs_dbg(VFS,
2676 "Persistent handles not supported on share\n");
2677 rc = -EOPNOTSUPP;
2678 goto out_fail;
Steve French592fafe2015-11-03 10:08:53 -06002679#endif /* CONFIG_CIFS_SMB2 */
Steve Frenchb618f002015-11-03 09:15:03 -06002680 }
Steve French592fafe2015-11-03 10:08:53 -06002681#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06002682 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2683 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2684 && (volume_info->nopersistent == false)) {
2685 cifs_dbg(FYI, "enabling persistent handles\n");
2686 tcon->use_persistent = true;
Steve French592fafe2015-11-03 10:08:53 -06002687#endif /* CONFIG_CIFS_SMB2 */
2688 } else if (volume_info->resilient) {
2689 if (ses->server->vals->protocol_id == 0) {
2690 cifs_dbg(VFS,
2691 "SMB2.1 or later required for resilient handles\n");
2692 rc = -EOPNOTSUPP;
2693 goto out_fail;
2694 }
2695 tcon->use_resilient = true;
Steve Frenchb618f002015-11-03 09:15:03 -06002696 }
2697
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002698 /*
2699 * We can have only one retry value for a connection to a share so for
2700 * resources mounted more than once to the same server share the last
2701 * value passed in for the retry flag is used.
2702 */
Jeff Laytond00c28d2010-04-24 07:57:44 -04002703 tcon->retry = volume_info->retry;
2704 tcon->nocase = volume_info->nocase;
2705 tcon->local_lease = volume_info->local_lease;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07002706 INIT_LIST_HEAD(&tcon->pending_opens);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002707
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302708 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002709 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302710 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002711
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302712 cifs_fscache_get_super_cookie(tcon);
2713
Jeff Laytond00c28d2010-04-24 07:57:44 -04002714 return tcon;
2715
2716out_fail:
2717 tconInfoFree(tcon);
2718 return ERR_PTR(rc);
2719}
2720
Jeff Layton9d002df2010-10-06 19:51:11 -04002721void
2722cifs_put_tlink(struct tcon_link *tlink)
2723{
2724 if (!tlink || IS_ERR(tlink))
2725 return;
2726
2727 if (!atomic_dec_and_test(&tlink->tl_count) ||
2728 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2729 tlink->tl_time = jiffies;
2730 return;
2731 }
2732
2733 if (!IS_ERR(tlink_tcon(tlink)))
2734 cifs_put_tcon(tlink_tcon(tlink));
2735 kfree(tlink);
2736 return;
2737}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002738
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002739static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002740cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2741{
2742 return cifs_sb->master_tlink;
2743}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002744
2745static int
2746compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2747{
2748 struct cifs_sb_info *old = CIFS_SB(sb);
2749 struct cifs_sb_info *new = mnt_data->cifs_sb;
2750
2751 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2752 return 0;
2753
2754 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2755 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2756 return 0;
2757
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002758 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002759 * We want to share sb only if we don't specify an r/wsize or
2760 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002761 */
2762 if (new->wsize && new->wsize < old->wsize)
2763 return 0;
2764
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002765 if (new->rsize && new->rsize < old->rsize)
2766 return 0;
2767
Eric W. Biederman1f682332013-02-06 01:20:20 -08002768 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002769 return 0;
2770
2771 if (old->mnt_file_mode != new->mnt_file_mode ||
2772 old->mnt_dir_mode != new->mnt_dir_mode)
2773 return 0;
2774
2775 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2776 return 0;
2777
2778 if (old->actimeo != new->actimeo)
2779 return 0;
2780
2781 return 1;
2782}
2783
2784int
2785cifs_match_super(struct super_block *sb, void *data)
2786{
2787 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2788 struct smb_vol *volume_info;
2789 struct cifs_sb_info *cifs_sb;
2790 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002791 struct cifs_ses *ses;
2792 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002793 struct tcon_link *tlink;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002794 int rc = 0;
2795
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002796 spin_lock(&cifs_tcp_ses_lock);
2797 cifs_sb = CIFS_SB(sb);
2798 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2799 if (IS_ERR(tlink)) {
2800 spin_unlock(&cifs_tcp_ses_lock);
2801 return rc;
2802 }
2803 tcon = tlink_tcon(tlink);
2804 ses = tcon->ses;
2805 tcp_srv = ses->server;
2806
2807 volume_info = mnt_data->vol;
2808
Jeff Layton9fa114f2012-11-26 11:09:57 -05002809 if (!match_server(tcp_srv, volume_info) ||
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002810 !match_session(ses, volume_info) ||
2811 !match_tcon(tcon, volume_info->UNC)) {
2812 rc = 0;
2813 goto out;
2814 }
2815
2816 rc = compare_mount_options(sb, mnt_data);
2817out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002818 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002819 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002820 return rc;
2821}
2822
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002824get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002825 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2826 struct dfs_info3_param **referrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827{
2828 char *temp_unc;
2829 int rc = 0;
2830
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002831 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002832 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002834 *num_referrals = 0;
2835 *referrals = NULL;
2836
2837 if (ses->ipc_tid == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838 temp_unc = kmalloc(2 /* for slashes */ +
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002839 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2840 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 if (temp_unc == NULL)
2842 return -ENOMEM;
2843 temp_unc[0] = '\\';
2844 temp_unc[1] = '\\';
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002845 strcpy(temp_unc + 2, ses->serverName);
2846 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2847 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2848 nls_codepage);
Joe Perchesf96637b2013-05-04 22:12:25 -05002849 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 kfree(temp_unc);
2851 }
2852 if (rc == 0)
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002853 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2854 referrals, num_referrals,
2855 nls_codepage, remap);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002856 /*
2857 * BB - map targetUNCs to dfs_info3 structures, here or in
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002858 * ses->server->ops->get_dfs_refer.
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002859 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860
2861 return rc;
2862}
2863
Jeff Layton09e50d52008-07-23 10:11:19 -04002864#ifdef CONFIG_DEBUG_LOCK_ALLOC
2865static struct lock_class_key cifs_key[2];
2866static struct lock_class_key cifs_slock_key[2];
2867
2868static inline void
2869cifs_reclassify_socket4(struct socket *sock)
2870{
2871 struct sock *sk = sock->sk;
Hannes Frederic Sowafafc4e12016-04-08 15:11:27 +02002872 BUG_ON(!sock_allow_reclassification(sk));
Jeff Layton09e50d52008-07-23 10:11:19 -04002873 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2874 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2875}
2876
2877static inline void
2878cifs_reclassify_socket6(struct socket *sock)
2879{
2880 struct sock *sk = sock->sk;
Hannes Frederic Sowafafc4e12016-04-08 15:11:27 +02002881 BUG_ON(!sock_allow_reclassification(sk));
Jeff Layton09e50d52008-07-23 10:11:19 -04002882 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2883 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2884}
2885#else
2886static inline void
2887cifs_reclassify_socket4(struct socket *sock)
2888{
2889}
2890
2891static inline void
2892cifs_reclassify_socket6(struct socket *sock)
2893{
2894}
2895#endif
2896
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002898static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899{
Steve French50c2f752007-07-13 00:33:32 +00002900 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901
Steve French50c2f752007-07-13 00:33:32 +00002902 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 /* mask a nibble at a time and encode */
2904 target[j] = 'A' + (0x0F & (source[i] >> 4));
2905 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002906 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002907 }
2908
2909}
2910
Ben Greear3eb9a882010-09-01 17:06:02 -07002911static int
2912bind_socket(struct TCP_Server_Info *server)
2913{
2914 int rc = 0;
2915 if (server->srcaddr.ss_family != AF_UNSPEC) {
2916 /* Bind to the specified local IP address */
2917 struct socket *socket = server->ssocket;
2918 rc = socket->ops->bind(socket,
2919 (struct sockaddr *) &server->srcaddr,
2920 sizeof(server->srcaddr));
2921 if (rc < 0) {
2922 struct sockaddr_in *saddr4;
2923 struct sockaddr_in6 *saddr6;
2924 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2925 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2926 if (saddr6->sin6_family == AF_INET6)
Joe Perchesf96637b2013-05-04 22:12:25 -05002927 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2928 &saddr6->sin6_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002929 else
Joe Perchesf96637b2013-05-04 22:12:25 -05002930 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2931 &saddr4->sin_addr.s_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002932 }
2933 }
2934 return rc;
2935}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936
2937static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002938ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939{
2940 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002941 /*
2942 * some servers require RFC1001 sessinit before sending
2943 * negprot - BB check reconnection in case where second
2944 * sessinit is sent but no second negprot
2945 */
2946 struct rfc1002_session_packet *ses_init_buf;
2947 struct smb_hdr *smb_buf;
2948 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2949 GFP_KERNEL);
2950 if (ses_init_buf) {
2951 ses_init_buf->trailer.session_req.called_len = 32;
2952
Colin Ian King997152f2016-01-25 16:25:54 +00002953 if (server->server_RFC1001_name[0] != 0)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002954 rfc1002mangle(ses_init_buf->trailer.
2955 session_req.called_name,
2956 server->server_RFC1001_name,
2957 RFC1001_NAME_LEN_WITH_NULL);
2958 else
2959 rfc1002mangle(ses_init_buf->trailer.
2960 session_req.called_name,
2961 DEFAULT_CIFS_CALLED_NAME,
2962 RFC1001_NAME_LEN_WITH_NULL);
2963
2964 ses_init_buf->trailer.session_req.calling_len = 32;
2965
2966 /*
2967 * calling name ends in null (byte 16) from old smb
2968 * convention.
2969 */
Steve Frenchc85c35f2015-03-27 01:15:02 -05002970 if (server->workstation_RFC1001_name[0] != 0)
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002971 rfc1002mangle(ses_init_buf->trailer.
2972 session_req.calling_name,
2973 server->workstation_RFC1001_name,
2974 RFC1001_NAME_LEN_WITH_NULL);
2975 else
2976 rfc1002mangle(ses_init_buf->trailer.
2977 session_req.calling_name,
2978 "LINUX_CIFS_CLNT",
2979 RFC1001_NAME_LEN_WITH_NULL);
2980
2981 ses_init_buf->trailer.session_req.scope1 = 0;
2982 ses_init_buf->trailer.session_req.scope2 = 0;
2983 smb_buf = (struct smb_hdr *)ses_init_buf;
2984
2985 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002986 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002987 rc = smb_send(server, smb_buf, 0x44);
2988 kfree(ses_init_buf);
2989 /*
2990 * RFC1001 layer in at least one server
2991 * requires very short break before negprot
2992 * presumably because not expecting negprot
2993 * to follow so fast. This is a simple
2994 * solution that works without
2995 * complicating the code and causes no
2996 * significant slowing down on mount
2997 * for everyone else
2998 */
2999 usleep_range(1000, 2000);
3000 }
3001 /*
3002 * else the negprot may still work without this
3003 * even though malloc failed
3004 */
3005
3006 return rc;
3007}
3008
3009static int
3010generic_ip_connect(struct TCP_Server_Info *server)
3011{
3012 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00003013 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003014 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003015 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003016 struct sockaddr *saddr;
3017
3018 saddr = (struct sockaddr *) &server->dstaddr;
3019
3020 if (server->dstaddr.ss_family == AF_INET6) {
3021 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3022 slen = sizeof(struct sockaddr_in6);
3023 sfamily = AF_INET6;
3024 } else {
3025 sport = ((struct sockaddr_in *) saddr)->sin_port;
3026 slen = sizeof(struct sockaddr_in);
3027 sfamily = AF_INET;
3028 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003030 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06003031 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3032 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003033 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003034 cifs_dbg(VFS, "Error %d creating socket\n", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003035 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003038
3039 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesf96637b2013-05-04 22:12:25 -05003040 cifs_dbg(FYI, "Socket created\n");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05003041 server->ssocket = socket;
3042 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003043 if (sfamily == AF_INET6)
3044 cifs_reclassify_socket6(socket);
3045 else
3046 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 }
3048
Ben Greear3eb9a882010-09-01 17:06:02 -07003049 rc = bind_socket(server);
3050 if (rc < 0)
3051 return rc;
3052
Jeff Laytond5c56052008-12-01 18:42:33 -05003053 /*
3054 * Eventually check for other socket options to change from
3055 * the default. sock_setsockopt not used because it expects
3056 * user space buffer
3057 */
3058 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003059 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003060
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003061 /* make the bufsizes depend on wsize/rsize and max requests */
3062 if (server->noautotune) {
3063 if (socket->sk->sk_sndbuf < (200 * 1024))
3064 socket->sk->sk_sndbuf = 200 * 1024;
3065 if (socket->sk->sk_rcvbuf < (140 * 1024))
3066 socket->sk->sk_rcvbuf = 140 * 1024;
3067 }
3068
Steve French6a5fa2362010-01-01 01:28:43 +00003069 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003070 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003071 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3072 (char *)&val, sizeof(val));
3073 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003074 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3075 rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003076 }
3077
Joe Perchesf96637b2013-05-04 22:12:25 -05003078 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003079 socket->sk->sk_sndbuf,
3080 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3081
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003082 rc = socket->ops->connect(socket, saddr, slen, 0);
3083 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003084 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003085 sock_release(socket);
3086 server->ssocket = NULL;
3087 return rc;
3088 }
3089
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003090 if (sport == htons(RFC1001_PORT))
3091 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003092
Linus Torvalds1da177e2005-04-16 15:20:36 -07003093 return rc;
3094}
3095
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003096static int
3097ip_connect(struct TCP_Server_Info *server)
3098{
Steve French6da97912011-03-13 18:55:55 +00003099 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003100 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3101 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3102
3103 if (server->dstaddr.ss_family == AF_INET6)
3104 sport = &addr6->sin6_port;
3105 else
3106 sport = &addr->sin_port;
3107
3108 if (*sport == 0) {
3109 int rc;
3110
3111 /* try with 445 port at first */
3112 *sport = htons(CIFS_PORT);
3113
3114 rc = generic_ip_connect(server);
3115 if (rc >= 0)
3116 return rc;
3117
3118 /* if it failed, try with 139 port */
3119 *sport = htons(RFC1001_PORT);
3120 }
3121
3122 return generic_ip_connect(server);
3123}
3124
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003125void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003126 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003127{
3128 /* if we are reconnecting then should we check to see if
3129 * any requested capabilities changed locally e.g. via
3130 * remount but we can not do much about it here
3131 * if they have (even if we could detect it by the following)
3132 * Perhaps we could add a backpointer to array of sb from tcon
3133 * or if we change to make all sb to same share the same
3134 * sb as NFS - then we only have one backpointer to sb.
3135 * What if we wanted to mount the server share twice once with
3136 * and once without posixacls or posix paths? */
3137 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003138
Steve Frenchc18c8422007-07-18 23:21:09 +00003139 if (vol_info && vol_info->no_linux_ext) {
3140 tcon->fsUnixInfo.Capability = 0;
3141 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesf96637b2013-05-04 22:12:25 -05003142 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003143 return;
3144 } else if (vol_info)
3145 tcon->unix_ext = 1; /* Unix Extensions supported */
3146
3147 if (tcon->unix_ext == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003148 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003149 return;
3150 }
Steve French50c2f752007-07-13 00:33:32 +00003151
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003152 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003153 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Joe Perchesf96637b2013-05-04 22:12:25 -05003154 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
Steve French8af18972007-02-14 04:42:51 +00003155 /* check for reconnect case in which we do not
3156 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003157 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003158 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003159 originally at mount time */
3160 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3161 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003162 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3163 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003164 cifs_dbg(VFS, "POSIXPATH support change\n");
Steve French8af18972007-02-14 04:42:51 +00003165 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003166 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003167 cifs_dbg(VFS, "possible reconnect error\n");
3168 cifs_dbg(VFS, "server disabled POSIX path support\n");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003169 }
Steve French8af18972007-02-14 04:42:51 +00003170 }
Steve French50c2f752007-07-13 00:33:32 +00003171
Steve French6848b732011-05-26 18:38:54 +00003172 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003173 cifs_dbg(VFS, "per-share encryption not supported yet\n");
Steve French6848b732011-05-26 18:38:54 +00003174
Steve French8af18972007-02-14 04:42:51 +00003175 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003176 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003177 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003178 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003179 cifs_dbg(FYI, "negotiated posix acl support\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003180 if (cifs_sb)
3181 cifs_sb->mnt_cifs_flags |=
3182 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003183 }
3184
Steve French75865f8c2007-06-24 18:30:48 +00003185 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003186 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003187 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003188 cifs_dbg(FYI, "negotiate posix pathnames\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003189 if (cifs_sb)
3190 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003191 CIFS_MOUNT_POSIX_PATHS;
3192 }
Steve French50c2f752007-07-13 00:33:32 +00003193
Joe Perchesf96637b2013-05-04 22:12:25 -05003194 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003195#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003196 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003197 cifs_dbg(FYI, "FCNTL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003198 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003199 cifs_dbg(FYI, "EXTATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003200 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003201 cifs_dbg(FYI, "POSIX path cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003202 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003203 cifs_dbg(FYI, "XATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003204 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003205 cifs_dbg(FYI, "POSIX ACL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003206 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003207 cifs_dbg(FYI, "very large read cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003208 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003209 cifs_dbg(FYI, "very large write cap\n");
Steve French6848b732011-05-26 18:38:54 +00003210 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003211 cifs_dbg(FYI, "transport encryption cap\n");
Steve French6848b732011-05-26 18:38:54 +00003212 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003213 cifs_dbg(FYI, "mandatory transport encryption cap\n");
Steve French8af18972007-02-14 04:42:51 +00003214#endif /* CIFS_DEBUG2 */
3215 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003216 if (vol_info == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003217 cifs_dbg(FYI, "resetting capabilities failed\n");
Steve French442aa312007-09-24 20:25:46 +00003218 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05003219 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
Steve French5a44b312007-09-20 15:16:24 +00003220
Steve French8af18972007-02-14 04:42:51 +00003221 }
3222 }
3223}
3224
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003225void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3226 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003227{
Jeff Layton2de970f2010-10-06 19:51:12 -04003228 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3229
Al Viro2ced6f62011-06-17 09:20:04 -04003230 spin_lock_init(&cifs_sb->tlink_tree_lock);
3231 cifs_sb->tlink_tree = RB_ROOT;
3232
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003233 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003234 * Temporarily set r/wsize for matching superblock. If we end up using
3235 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003236 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003237 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003238 cifs_sb->wsize = pvolume_info->wsize;
3239
Steve French3b795212008-11-13 19:45:32 +00003240 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3241 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3242 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3243 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -05003244 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3245 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003246
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303247 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003248 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303249
Steve French3b795212008-11-13 19:45:32 +00003250 if (pvolume_info->noperm)
3251 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3252 if (pvolume_info->setuids)
3253 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3254 if (pvolume_info->server_ino)
3255 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3256 if (pvolume_info->remap)
Steve French2baa2682014-09-27 02:19:01 -05003257 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3258 if (pvolume_info->sfu_remap)
Steve French3b795212008-11-13 19:45:32 +00003259 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3260 if (pvolume_info->no_xattr)
3261 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3262 if (pvolume_info->sfu_emul)
3263 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3264 if (pvolume_info->nobrl)
3265 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003266 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003267 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003268 if (pvolume_info->mand_lock)
3269 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003270 if (pvolume_info->rwpidforward)
3271 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003272 if (pvolume_info->cifs_acl)
3273 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003274 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003275 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003276 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3277 }
3278 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003279 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003280 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3281 }
Steve French3b795212008-11-13 19:45:32 +00003282 if (pvolume_info->override_uid)
3283 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3284 if (pvolume_info->override_gid)
3285 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3286 if (pvolume_info->dynperm)
3287 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303288 if (pvolume_info->fsc)
3289 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003290 if (pvolume_info->multiuser)
3291 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3292 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003293 if (pvolume_info->strict_io)
3294 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003295 if (pvolume_info->direct_io) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003296 cifs_dbg(FYI, "mounting share using direct i/o\n");
Steve French3b795212008-11-13 19:45:32 +00003297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3298 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003299 if (pvolume_info->mfsymlinks) {
3300 if (pvolume_info->sfu_emul) {
Steve Frenchdb8b6312014-09-22 05:13:55 -05003301 /*
3302 * Our SFU ("Services for Unix" emulation does not allow
3303 * creating symlinks but does allow reading existing SFU
3304 * symlinks (it does allow both creating and reading SFU
3305 * style mknod and FIFOs though). When "mfsymlinks" and
3306 * "sfu" are both enabled at the same time, it allows
3307 * reading both types of symlinks, but will only create
3308 * them with mfsymlinks format. This allows better
3309 * Apple compatibility (probably better for Samba too)
3310 * while still recognizing old Windows style symlinks.
3311 */
3312 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003313 }
Steve Frenchdb8b6312014-09-22 05:13:55 -05003314 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003315 }
Steve French3b795212008-11-13 19:45:32 +00003316
3317 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesf96637b2013-05-04 22:12:25 -05003318 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003319}
3320
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003321static void
3322cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003323{
Sean Finneyb9468452011-04-11 13:19:32 +00003324 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003325 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003326 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003327 kfree(volume_info->domainname);
3328 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003329 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003330}
3331
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003332void
3333cifs_cleanup_volume_info(struct smb_vol *volume_info)
3334{
3335 if (!volume_info)
3336 return;
3337 cleanup_volume_info_contents(volume_info);
3338 kfree(volume_info);
3339}
3340
3341
Steve French2d6d5892009-04-09 00:36:44 +00003342#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003343/*
3344 * cifs_build_path_to_root returns full path to root when we do not have an
3345 * exiting connection (tcon)
3346 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003347static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003348build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003349 const struct cifs_sb_info *cifs_sb)
3350{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003351 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003352 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003353 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003354
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003355 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003356 if (full_path == NULL)
3357 return ERR_PTR(-ENOMEM);
3358
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003359 strncpy(full_path, vol->UNC, unc_len);
3360 pos = full_path + unc_len;
3361
3362 if (pplen) {
Jeff Layton1fc29ba2013-05-31 10:00:18 -04003363 *pos = CIFS_DIR_SEP(cifs_sb);
3364 strncpy(pos + 1, vol->prepath, pplen);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003365 pos += pplen;
3366 }
3367
3368 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003369 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05003370 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003371 return full_path;
3372}
Sean Finneydd613942011-04-11 13:19:30 +00003373
3374/*
3375 * Perform a dfs referral query for a share and (optionally) prefix
3376 *
Sean Finney046462a2011-04-11 13:19:33 +00003377 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3378 * to a string containing updated options for the submount. Otherwise it
3379 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003380 *
3381 * Returns the rc from get_dfs_path to the caller, which can be used to
3382 * determine whether there were referrals.
3383 */
3384static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003385expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003386 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003387 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003388{
3389 int rc;
3390 unsigned int num_referrals = 0;
3391 struct dfs_info3_param *referrals = NULL;
3392 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3393
3394 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3395 if (IS_ERR(full_path))
3396 return PTR_ERR(full_path);
3397
3398 /* For DFS paths, skip the first '\' of the UNC */
3399 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3400
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003401 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05003402 &num_referrals, &referrals, cifs_remap(cifs_sb));
Sean Finneydd613942011-04-11 13:19:30 +00003403
3404 if (!rc && num_referrals > 0) {
3405 char *fake_devname = NULL;
3406
3407 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3408 full_path + 1, referrals,
3409 &fake_devname);
3410
3411 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003412
Sean Finneydd613942011-04-11 13:19:30 +00003413 if (IS_ERR(mdata)) {
3414 rc = PTR_ERR(mdata);
3415 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003416 } else {
3417 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003418 rc = cifs_setup_volume_info(volume_info, mdata,
3419 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003420 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003421 kfree(fake_devname);
3422 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003423 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003424 }
3425 kfree(full_path);
3426 return rc;
3427}
Steve French2d6d5892009-04-09 00:36:44 +00003428#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003429
Jeff Layton04db79b2011-07-06 08:10:38 -04003430static int
3431cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3432 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003434 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003435
Jeff Layton04db79b2011-07-06 08:10:38 -04003436 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3437 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438
Jeff Layton7586b762008-12-01 18:41:49 -05003439 if (volume_info->nullauth) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003440 cifs_dbg(FYI, "Anonymous login\n");
Jeff Layton04febab2012-01-17 16:09:15 -05003441 kfree(volume_info->username);
3442 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003443 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 /* BB fixme parse for domain name here */
Joe Perchesf96637b2013-05-04 22:12:25 -05003445 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003447 cifs_dbg(VFS, "No username specified\n");
Steve French50c2f752007-07-13 00:33:32 +00003448 /* In userspace mount helper we can get user name from alternate
3449 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003450 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 }
3452
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003454 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003455 /* load_nls_default cannot return null */
3456 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003458 volume_info->local_nls = load_nls(volume_info->iocharset);
3459 if (volume_info->local_nls == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003460 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003461 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003462 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 }
3464 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003465
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003466 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003467}
3468
3469struct smb_vol *
3470cifs_get_volume_info(char *mount_data, const char *devname)
3471{
3472 int rc;
3473 struct smb_vol *volume_info;
3474
Jeff Layton6ee95422012-11-26 11:09:57 -05003475 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003476 if (!volume_info)
3477 return ERR_PTR(-ENOMEM);
3478
3479 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3480 if (rc) {
3481 cifs_cleanup_volume_info(volume_info);
3482 volume_info = ERR_PTR(rc);
3483 }
3484
3485 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003486}
3487
Aurelien Aptela6b50582016-05-25 19:59:09 +02003488static int
3489cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3490 unsigned int xid,
3491 struct cifs_tcon *tcon,
3492 struct cifs_sb_info *cifs_sb,
3493 char *full_path)
3494{
3495 int rc;
3496 char *s;
3497 char sep, tmp;
3498
3499 sep = CIFS_DIR_SEP(cifs_sb);
3500 s = full_path;
3501
3502 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3503 while (rc == 0) {
3504 /* skip separators */
3505 while (*s == sep)
3506 s++;
3507 if (!*s)
3508 break;
3509 /* next separator */
3510 while (*s && *s != sep)
3511 s++;
3512
3513 /*
3514 * temporarily null-terminate the path at the end of
3515 * the current component
3516 */
3517 tmp = *s;
3518 *s = 0;
3519 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3520 full_path);
3521 *s = tmp;
3522 }
3523 return rc;
3524}
3525
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003526int
Al Viro2c6292a2011-06-17 09:05:48 -04003527cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003528{
Jeff Layton1daaae82012-03-21 06:30:40 -04003529 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003530 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003531 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003532 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003533 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003534 char *full_path;
3535 struct tcon_link *tlink;
3536#ifdef CONFIG_CIFS_DFS_UPCALL
3537 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003538#endif
Al Virodd854462011-06-17 08:24:42 -04003539
Christoph Hellwigb4caecd2015-01-14 10:42:32 +01003540 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
Al Virodd854462011-06-17 08:24:42 -04003541 if (rc)
3542 return rc;
3543
Jeff Layton20547492011-07-09 12:21:07 -04003544#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003545try_mount_again:
3546 /* cleanup activities if we're chasing a referral */
3547 if (referral_walks_count) {
3548 if (tcon)
3549 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003550 else if (ses)
3551 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003552
Sachin Prabhu1dfd18d2015-06-16 16:36:17 +01003553 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3554
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003555 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003556 }
3557#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003558 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003559 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003560 ses = NULL;
3561 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003562 full_path = NULL;
3563 tlink = NULL;
3564
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003565 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566
Jeff Layton63c038c2008-12-01 18:41:46 -05003567 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003568 server = cifs_get_tcp_session(volume_info);
3569 if (IS_ERR(server)) {
3570 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003571 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003572 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573 }
3574
Jeff Layton36988c72010-04-24 07:57:43 -04003575 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003576 ses = cifs_get_smb_ses(server, volume_info);
3577 if (IS_ERR(ses)) {
3578 rc = PTR_ERR(ses);
3579 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003580 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 }
Steve French50c2f752007-07-13 00:33:32 +00003582
Steve French592fafe2015-11-03 10:08:53 -06003583#ifdef CONFIG_CIFS_SMB2
Steve Frenchb618f002015-11-03 09:15:03 -06003584 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3585 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3586 cifs_dbg(VFS, "persistent handles not supported by server\n");
3587 rc = -EOPNOTSUPP;
3588 goto mount_fail_check;
3589 }
Steve French592fafe2015-11-03 10:08:53 -06003590#endif /* CONFIG_CIFS_SMB2*/
3591
Jeff Laytond00c28d2010-04-24 07:57:44 -04003592 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003593 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003594 if (IS_ERR(tcon)) {
3595 rc = PTR_ERR(tcon);
3596 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003597 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003598 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003599
Steve French6848b732011-05-26 18:38:54 +00003600 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003601 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003602 /* reset of caps checks mount to see if unix extensions
3603 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003604 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003605 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3606 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3607 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3608 rc = -EACCES;
3609 goto mount_fail_check;
3610 }
3611 } else
3612 tcon->unix_ext = 0; /* server does not support them */
3613
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003614 /* do not care if a following call succeed - informational */
3615 if (!tcon->ipc && server->ops->qfs_tcon)
3616 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003617
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003618 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3619 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003620
Jeff Layton66bfaad2011-10-19 15:30:35 -04003621 /* tune readahead according to rsize */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003622 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003623
Igor Mammedove4cce942009-02-10 14:10:26 +03003624remote_path_check:
3625#ifdef CONFIG_CIFS_DFS_UPCALL
3626 /*
3627 * Perform an unconditional check for whether there are DFS
3628 * referrals for this path without prefix, to provide support
3629 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003630 * with PATH_NOT_COVERED to requests that include the prefix.
3631 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003632 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003633 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003634 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3635 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003636 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003637 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638 goto try_mount_again;
3639 }
3640 }
3641#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003642
Steve Frenchf87d39d2011-05-27 03:50:55 +00003643 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003644 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003645 if (!server->ops->is_path_accessible) {
3646 rc = -ENOSYS;
3647 goto mount_fail_check;
3648 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003649 /*
3650 * cifs_build_path_to_root works only when we have a valid tcon
3651 */
3652 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653 if (full_path == NULL) {
3654 rc = -ENOMEM;
3655 goto mount_fail_check;
3656 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003657 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3658 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003659 if (rc != 0 && rc != -EREMOTE) {
3660 kfree(full_path);
3661 goto mount_fail_check;
3662 }
Aurelien Aptela6b50582016-05-25 19:59:09 +02003663
3664 rc = cifs_are_all_path_components_accessible(server,
3665 xid, tcon, cifs_sb,
3666 full_path);
3667 if (rc != 0) {
3668 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3669 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3670 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3671 rc = 0;
3672 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673 kfree(full_path);
3674 }
3675
3676 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003677 if (rc == -EREMOTE) {
3678#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003679 if (referral_walks_count > MAX_NESTED_LINKS) {
3680 /*
3681 * BB: when we implement proper loop detection,
3682 * we will remove this check. But now we need it
3683 * to prevent an indefinite loop if 'DFS tree' is
3684 * misconfigured (i.e. has loops).
3685 */
3686 rc = -ELOOP;
3687 goto mount_fail_check;
3688 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003689
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003690 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003691
Sean Finneydd613942011-04-11 13:19:30 +00003692 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003693 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003694 goto try_mount_again;
3695 }
Sean Finneydd613942011-04-11 13:19:30 +00003696 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003697#else /* No DFS support, return error on mount */
3698 rc = -EOPNOTSUPP;
3699#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003700 }
3701
Jeff Layton9d002df2010-10-06 19:51:11 -04003702 if (rc)
3703 goto mount_fail_check;
3704
3705 /* now, hang the tcon off of the superblock */
3706 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3707 if (tlink == NULL) {
3708 rc = -ENOMEM;
3709 goto mount_fail_check;
3710 }
3711
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003712 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003713 tlink->tl_tcon = tcon;
3714 tlink->tl_time = jiffies;
3715 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3716 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3717
Jeff Layton413e6612010-10-28 13:33:38 -04003718 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003719 spin_lock(&cifs_sb->tlink_tree_lock);
3720 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3721 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003722
Jeff Laytonda472fc2012-03-23 14:40:53 -04003723 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003724 TLINK_IDLE_EXPIRE);
3725
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003726mount_fail_check:
3727 /* on error free sesinfo and tcon struct if needed */
3728 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003729 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003730 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003731 if (tcon)
3732 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003733 else if (ses)
3734 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003735 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003736 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003737 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003738 }
3739
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003741 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 return rc;
3743}
3744
Jeff Layton8d1bca32011-06-11 21:17:10 -04003745/*
3746 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3747 * pointer may be NULL.
3748 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003750CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003751 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 const struct nls_table *nls_codepage)
3753{
3754 struct smb_hdr *smb_buffer;
3755 struct smb_hdr *smb_buffer_response;
3756 TCONX_REQ *pSMB;
3757 TCONX_RSP *pSMBr;
3758 unsigned char *bcc_ptr;
3759 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003760 int length;
3761 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003762
3763 if (ses == NULL)
3764 return -EIO;
3765
3766 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003767 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003768 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003769
Linus Torvalds1da177e2005-04-16 15:20:36 -07003770 smb_buffer_response = smb_buffer;
3771
3772 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3773 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003774
Pavel Shilovsky88257362012-05-23 14:01:59 +04003775 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 smb_buffer->Uid = ses->Suid;
3777 pSMB = (TCONX_REQ *) smb_buffer;
3778 pSMBr = (TCONX_RSP *) smb_buffer_response;
3779
3780 pSMB->AndXCommand = 0xFF;
3781 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003782 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003783 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003784 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003785 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003786 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003787 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003788 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003789 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003790 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3791 specified as required (when that support is added to
3792 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003793 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003794 by Samba (not sure whether other servers allow
3795 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003796#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003797 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton3f618222013-06-12 19:52:14 -05003798 (ses->sectype == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003799 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003800 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003801 SECMODE_PW_ENCRYPT ? true : false,
3802 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003803 else
3804#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003805 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003806 bcc_ptr, nls_codepage);
Steve Frenchf3a31a22015-03-26 19:23:20 -05003807 if (rc) {
3808 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3809 __func__, rc);
3810 cifs_buf_release(smb_buffer);
3811 return rc;
3812 }
Steve Frencheeac8042006-01-13 21:34:58 -08003813
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003814 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003815 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003816 /* must align unicode strings */
3817 *bcc_ptr = 0; /* null byte password */
3818 bcc_ptr++;
3819 }
Steve Frencheeac8042006-01-13 21:34:58 -08003820 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003821
Jeff Layton38d77c52013-05-26 07:01:00 -04003822 if (ses->server->sign)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003823 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3824
3825 if (ses->capabilities & CAP_STATUS32) {
3826 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3827 }
3828 if (ses->capabilities & CAP_DFS) {
3829 smb_buffer->Flags2 |= SMBFLG2_DFS;
3830 }
3831 if (ses->capabilities & CAP_UNICODE) {
3832 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3833 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003834 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003835 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003836 (/* server len*/ + 256 /* share len */), nls_codepage);
3837 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 bcc_ptr += 2; /* skip trailing null */
3839 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840 strcpy(bcc_ptr, tree);
3841 bcc_ptr += strlen(tree) + 1;
3842 }
3843 strcpy(bcc_ptr, "?????");
3844 bcc_ptr += strlen("?????");
3845 bcc_ptr += 1;
3846 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003847 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3848 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 pSMB->ByteCount = cpu_to_le16(count);
3850
Steve French133672e2007-11-13 22:41:37 +00003851 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003852 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853
Linus Torvalds1da177e2005-04-16 15:20:36 -07003854 /* above now done in SendReceive */
3855 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003856 bool is_unicode;
3857
Linus Torvalds1da177e2005-04-16 15:20:36 -07003858 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003859 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 tcon->tid = smb_buffer_response->Tid;
3861 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003862 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003863 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003864 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3865 is_unicode = true;
3866 else
3867 is_unicode = false;
3868
Jeff Laytoncc20c032009-04-30 07:16:21 -04003869
Steve French50c2f752007-07-13 00:33:32 +00003870 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003871 if (length == 3) {
3872 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3873 (bcc_ptr[2] == 'C')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003874 cifs_dbg(FYI, "IPC connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003875 tcon->ipc = 1;
3876 }
3877 } else if (length == 2) {
3878 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3879 /* the most common case */
Joe Perchesf96637b2013-05-04 22:12:25 -05003880 cifs_dbg(FYI, "disk share connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003881 }
3882 }
Steve French50c2f752007-07-13 00:33:32 +00003883 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003884 bytes_left -= (length + 1);
Zhao Hongjiang46b51d02013-06-24 01:57:47 -05003885 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
Jeff Laytoncc20c032009-04-30 07:16:21 -04003886
3887 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003888 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003889 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003890 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003891 nls_codepage);
3892
Joe Perchesf96637b2013-05-04 22:12:25 -05003893 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003894
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003895 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003896 (smb_buffer_response->WordCount == 7))
3897 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003898 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3899 else
3900 tcon->Flags = 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003901 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003903 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003904 ses->ipc_tid = smb_buffer_response->Tid;
3905 }
3906
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003907 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003908 return rc;
3909}
3910
Al Viro2e32cf52013-10-03 12:53:37 -04003911static void delayed_free(struct rcu_head *p)
3912{
3913 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3914 unload_nls(sbi->local_nls);
3915 kfree(sbi);
3916}
3917
Al Viro2a9b9952011-06-17 09:27:16 -04003918void
3919cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920{
Jeff Laytonb647c352010-10-28 11:16:44 -04003921 struct rb_root *root = &cifs_sb->tlink_tree;
3922 struct rb_node *node;
3923 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003924
Jeff Layton2de970f2010-10-06 19:51:12 -04003925 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3926
Jeff Laytonb647c352010-10-28 11:16:44 -04003927 spin_lock(&cifs_sb->tlink_tree_lock);
3928 while ((node = rb_first(root))) {
3929 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3930 cifs_get_tlink(tlink);
3931 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3932 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003933
Jeff Laytonb647c352010-10-28 11:16:44 -04003934 spin_unlock(&cifs_sb->tlink_tree_lock);
3935 cifs_put_tlink(tlink);
3936 spin_lock(&cifs_sb->tlink_tree_lock);
3937 }
3938 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003939
Al Virodd854462011-06-17 08:24:42 -04003940 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003941 kfree(cifs_sb->mountdata);
Aurelien Aptela6b50582016-05-25 19:59:09 +02003942 kfree(cifs_sb->prepath);
Al Viro2e32cf52013-10-03 12:53:37 -04003943 call_rcu(&cifs_sb->rcu, delayed_free);
Steve French50c2f752007-07-13 00:33:32 +00003944}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003946int
3947cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003948{
3949 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003950 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003952 if (!server->ops->need_neg || !server->ops->negotiate)
3953 return -ENOSYS;
3954
Jeff Layton198b5682010-04-24 07:57:48 -04003955 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003956 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003957 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958
Pavel Shilovsky45275782012-05-17 17:53:29 +04003959 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003960
3961 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003962 if (rc == 0) {
3963 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003964 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003965 server->tcpStatus = CifsGood;
3966 else
3967 rc = -EHOSTDOWN;
3968 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 }
Steve French26b994f2008-08-06 05:11:33 +00003970
Jeff Layton198b5682010-04-24 07:57:48 -04003971 return rc;
3972}
Steve French26b994f2008-08-06 05:11:33 +00003973
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003974int
3975cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3976 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003977{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003978 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003979 struct TCP_Server_Info *server = ses->server;
3980
Jeff Layton198b5682010-04-24 07:57:48 -04003981 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003982 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003983 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003984
Joe Perchesf96637b2013-05-04 22:12:25 -05003985 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
Steve French96daf2b2011-05-27 04:34:02 +00003986 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003987
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003988 if (server->ops->sess_setup)
3989 rc = server->ops->sess_setup(xid, ses, nls_info);
3990
Shirish Pargaonkard4e63bd2013-08-29 08:35:09 -05003991 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003992 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003993
Linus Torvalds1da177e2005-04-16 15:20:36 -07003994 return rc;
3995}
3996
Jeff Layton8a8798a2012-01-17 16:09:15 -05003997static int
3998cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3999{
Jeff Layton3f618222013-06-12 19:52:14 -05004000 vol->sectype = ses->sectype;
4001
4002 /* krb5 is special, since we don't need username or pw */
4003 if (vol->sectype == Kerberos)
Jeff Layton8a8798a2012-01-17 16:09:15 -05004004 return 0;
Jeff Layton8a8798a2012-01-17 16:09:15 -05004005
4006 return cifs_set_cifscreds(vol, ses);
4007}
4008
Steve French96daf2b2011-05-27 04:34:02 +00004009static struct cifs_tcon *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004010cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
Jeff Layton9d002df2010-10-06 19:51:11 -04004011{
Jeff Layton8a8798a2012-01-17 16:09:15 -05004012 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00004013 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4014 struct cifs_ses *ses;
4015 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04004016 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04004017
4018 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03004019 if (vol_info == NULL)
4020 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04004021
Jeff Layton9d002df2010-10-06 19:51:11 -04004022 vol_info->local_nls = cifs_sb->local_nls;
4023 vol_info->linux_uid = fsuid;
4024 vol_info->cred_uid = fsuid;
4025 vol_info->UNC = master_tcon->treeName;
4026 vol_info->retry = master_tcon->retry;
4027 vol_info->nocase = master_tcon->nocase;
4028 vol_info->local_lease = master_tcon->local_lease;
4029 vol_info->no_linux_ext = !master_tcon->unix_ext;
Jeff Layton28e11bd2013-05-26 07:01:00 -04004030 vol_info->sectype = master_tcon->ses->sectype;
4031 vol_info->sign = master_tcon->ses->sign;
Jeff Layton9d002df2010-10-06 19:51:11 -04004032
Jeff Layton8a8798a2012-01-17 16:09:15 -05004033 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4034 if (rc) {
4035 tcon = ERR_PTR(rc);
4036 goto out;
4037 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004038
4039 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304040 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004041 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05304042 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004043
4044 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4045 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00004046 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04004047 cifs_put_tcp_session(master_tcon->ses->server);
4048 goto out;
4049 }
4050
4051 tcon = cifs_get_tcon(ses, vol_info);
4052 if (IS_ERR(tcon)) {
4053 cifs_put_smb_ses(ses);
4054 goto out;
4055 }
4056
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04004057 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04004058 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4059out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05004060 kfree(vol_info->username);
4061 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04004062 kfree(vol_info);
4063
4064 return tcon;
4065}
4066
Steve French96daf2b2011-05-27 04:34:02 +00004067struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04004068cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4069{
4070 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4071}
4072
Jeff Laytonb647c352010-10-28 11:16:44 -04004073/* find and return a tlink with given uid */
4074static struct tcon_link *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004075tlink_rb_search(struct rb_root *root, kuid_t uid)
Jeff Laytonb647c352010-10-28 11:16:44 -04004076{
4077 struct rb_node *node = root->rb_node;
4078 struct tcon_link *tlink;
4079
4080 while (node) {
4081 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4082
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004083 if (uid_gt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004084 node = node->rb_left;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004085 else if (uid_lt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004086 node = node->rb_right;
4087 else
4088 return tlink;
4089 }
4090 return NULL;
4091}
4092
4093/* insert a tcon_link into the tree */
4094static void
4095tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4096{
4097 struct rb_node **new = &(root->rb_node), *parent = NULL;
4098 struct tcon_link *tlink;
4099
4100 while (*new) {
4101 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4102 parent = *new;
4103
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004104 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04004105 new = &((*new)->rb_left);
4106 else
4107 new = &((*new)->rb_right);
4108 }
4109
4110 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4111 rb_insert_color(&new_tlink->tl_rbnode, root);
4112}
4113
Jeff Layton9d002df2010-10-06 19:51:11 -04004114/*
4115 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4116 * current task.
4117 *
4118 * If the superblock doesn't refer to a multiuser mount, then just return
4119 * the master tcon for the mount.
4120 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304121 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004122 * exists, then check to see if it's pending construction. If it is then wait
4123 * for construction to complete. Once it's no longer pending, check to see if
4124 * it failed and either return an error or retry construction, depending on
4125 * the timeout.
4126 *
4127 * If one doesn't exist then insert a new tcon_link struct into the tree and
4128 * try to construct a new one.
4129 */
4130struct tcon_link *
4131cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4132{
4133 int ret;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004134 kuid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004135 struct tcon_link *tlink, *newtlink;
4136
4137 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4138 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4139
4140 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004141 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004142 if (tlink)
4143 cifs_get_tlink(tlink);
4144 spin_unlock(&cifs_sb->tlink_tree_lock);
4145
4146 if (tlink == NULL) {
4147 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4148 if (newtlink == NULL)
4149 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004150 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004151 newtlink->tl_tcon = ERR_PTR(-EACCES);
4152 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4153 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4154 cifs_get_tlink(newtlink);
4155
Jeff Layton9d002df2010-10-06 19:51:11 -04004156 spin_lock(&cifs_sb->tlink_tree_lock);
4157 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004158 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004159 if (tlink) {
4160 cifs_get_tlink(tlink);
4161 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004162 kfree(newtlink);
4163 goto wait_for_construction;
4164 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004165 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004166 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4167 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004168 } else {
4169wait_for_construction:
4170 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
Jeff Layton9d002df2010-10-06 19:51:11 -04004171 TASK_INTERRUPTIBLE);
4172 if (ret) {
4173 cifs_put_tlink(tlink);
NeilBrown74316202014-07-07 15:16:04 +10004174 return ERR_PTR(-ERESTARTSYS);
Jeff Layton9d002df2010-10-06 19:51:11 -04004175 }
4176
4177 /* if it's good, return it */
4178 if (!IS_ERR(tlink->tl_tcon))
4179 return tlink;
4180
4181 /* return error if we tried this already recently */
4182 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4183 cifs_put_tlink(tlink);
4184 return ERR_PTR(-EACCES);
4185 }
4186
4187 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4188 goto wait_for_construction;
4189 }
4190
4191 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4192 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4193 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4194
4195 if (IS_ERR(tlink->tl_tcon)) {
4196 cifs_put_tlink(tlink);
4197 return ERR_PTR(-EACCES);
4198 }
4199
4200 return tlink;
4201}
Jeff Layton2de970f2010-10-06 19:51:12 -04004202
4203/*
4204 * periodic workqueue job that scans tcon_tree for a superblock and closes
4205 * out tcons.
4206 */
4207static void
4208cifs_prune_tlinks(struct work_struct *work)
4209{
4210 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4211 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004212 struct rb_root *root = &cifs_sb->tlink_tree;
4213 struct rb_node *node = rb_first(root);
4214 struct rb_node *tmp;
4215 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004216
Jeff Laytonb647c352010-10-28 11:16:44 -04004217 /*
4218 * Because we drop the spinlock in the loop in order to put the tlink
4219 * it's not guarded against removal of links from the tree. The only
4220 * places that remove entries from the tree are this function and
4221 * umounts. Because this function is non-reentrant and is canceled
4222 * before umount can proceed, this is safe.
4223 */
4224 spin_lock(&cifs_sb->tlink_tree_lock);
4225 node = rb_first(root);
4226 while (node != NULL) {
4227 tmp = node;
4228 node = rb_next(tmp);
4229 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4230
4231 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4232 atomic_read(&tlink->tl_count) != 0 ||
4233 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4234 continue;
4235
4236 cifs_get_tlink(tlink);
4237 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4238 rb_erase(tmp, root);
4239
Jeff Layton2de970f2010-10-06 19:51:12 -04004240 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004241 cifs_put_tlink(tlink);
4242 spin_lock(&cifs_sb->tlink_tree_lock);
4243 }
4244 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004245
Jeff Laytonda472fc2012-03-23 14:40:53 -04004246 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004247 TLINK_IDLE_EXPIRE);
4248}