blob: 2a772da16b839fe124d12db9256b74d95f37c97a [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,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040090
91 /* Mount options which take numeric value */
92 Opt_backupuid, Opt_backupgid, Opt_uid,
93 Opt_cruid, Opt_gid, Opt_file_mode,
94 Opt_dirmode, Opt_port,
95 Opt_rsize, Opt_wsize, Opt_actimeo,
96
97 /* Mount options which take string value */
98 Opt_user, Opt_pass, Opt_ip,
Jeff Layton73a999f2013-03-22 08:42:57 -040099 Opt_domain, Opt_srcaddr, Opt_iocharset,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400100 Opt_netbiosname, Opt_servern,
Jeff Layton23db65f2012-05-15 12:20:51 -0400101 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400102
103 /* Mount options to be ignored */
104 Opt_ignore,
105
106 /* Options which could be blank */
107 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100108 Opt_blank_user,
109 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400110
111 Opt_err
112};
113
114static const match_table_t cifs_mount_option_tokens = {
115
116 { Opt_user_xattr, "user_xattr" },
117 { Opt_nouser_xattr, "nouser_xattr" },
118 { Opt_forceuid, "forceuid" },
119 { Opt_noforceuid, "noforceuid" },
Jeff Layton72bd4812012-10-03 16:02:36 -0400120 { Opt_forcegid, "forcegid" },
121 { Opt_noforcegid, "noforcegid" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400122 { Opt_noblocksend, "noblocksend" },
123 { Opt_noautotune, "noautotune" },
124 { Opt_hard, "hard" },
125 { Opt_soft, "soft" },
126 { Opt_perm, "perm" },
127 { Opt_noperm, "noperm" },
Steve French2baa2682014-09-27 02:19:01 -0500128 { Opt_mapchars, "mapchars" }, /* SFU style */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400129 { Opt_nomapchars, "nomapchars" },
Steve French2baa2682014-09-27 02:19:01 -0500130 { Opt_mapposix, "mapposix" }, /* SFM style */
131 { Opt_nomapposix, "nomapposix" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400132 { Opt_sfu, "sfu" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
141 { Opt_brl, "brl" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400145 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
161 { Opt_acl, "acl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400166 { Opt_noac, "noac" },
167 { Opt_fsc, "fsc" },
168 { Opt_mfsymlinks, "mfsymlinks" },
169 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400170 { Opt_sloppy, "sloppy" },
Jeff Laytona0b3df52013-05-24 07:40:59 -0400171 { Opt_nosharesock, "nosharesock" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400172
173 { Opt_backupuid, "backupuid=%s" },
174 { Opt_backupgid, "backupgid=%s" },
175 { Opt_uid, "uid=%s" },
176 { Opt_cruid, "cruid=%s" },
177 { Opt_gid, "gid=%s" },
178 { Opt_file_mode, "file_mode=%s" },
179 { Opt_dirmode, "dirmode=%s" },
180 { Opt_dirmode, "dir_mode=%s" },
181 { Opt_port, "port=%s" },
182 { Opt_rsize, "rsize=%s" },
183 { Opt_wsize, "wsize=%s" },
184 { Opt_actimeo, "actimeo=%s" },
185
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100186 { Opt_blank_user, "user=" },
187 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400188 { Opt_user, "user=%s" },
189 { Opt_user, "username=%s" },
190 { Opt_blank_pass, "pass=" },
Jesper Nilsson3c15b4c2012-11-29 17:31:16 +0100191 { Opt_blank_pass, "password=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400192 { Opt_pass, "pass=%s" },
193 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100194 { Opt_blank_ip, "ip=" },
195 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400196 { Opt_ip, "ip=%s" },
197 { Opt_ip, "addr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400198 { Opt_ignore, "unc=%s" },
199 { Opt_ignore, "target=%s" },
200 { Opt_ignore, "path=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400201 { Opt_domain, "dom=%s" },
202 { Opt_domain, "domain=%s" },
203 { Opt_domain, "workgroup=%s" },
204 { Opt_srcaddr, "srcaddr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400205 { Opt_ignore, "prefixpath=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400206 { Opt_iocharset, "iocharset=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400207 { Opt_netbiosname, "netbiosname=%s" },
208 { Opt_servern, "servern=%s" },
209 { Opt_ver, "ver=%s" },
Jeff Layton23db65f2012-05-15 12:20:51 -0400210 { Opt_vers, "vers=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400211 { Opt_sec, "sec=%s" },
Jeff Layton15b6a472012-05-16 07:50:15 -0400212 { Opt_cache, "cache=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400213
214 { Opt_ignore, "cred" },
215 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400216 { Opt_ignore, "cred=%s" },
217 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400218 { Opt_ignore, "guest" },
219 { Opt_ignore, "rw" },
220 { Opt_ignore, "ro" },
221 { Opt_ignore, "suid" },
222 { Opt_ignore, "nosuid" },
223 { Opt_ignore, "exec" },
224 { Opt_ignore, "noexec" },
225 { Opt_ignore, "nodev" },
226 { Opt_ignore, "noauto" },
227 { Opt_ignore, "dev" },
228 { Opt_ignore, "mand" },
229 { Opt_ignore, "nomand" },
230 { Opt_ignore, "_netdev" },
231
232 { Opt_err, NULL }
233};
234
235enum {
236 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
237 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
Jeff Layton76596242012-07-23 20:34:17 -0400238 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
239 Opt_sec_ntlmv2i, Opt_sec_lanman,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400240 Opt_sec_none,
241
242 Opt_sec_err
243};
244
245static const match_table_t cifs_secflavor_tokens = {
246 { Opt_sec_krb5, "krb5" },
247 { Opt_sec_krb5i, "krb5i" },
248 { Opt_sec_krb5p, "krb5p" },
249 { Opt_sec_ntlmsspi, "ntlmsspi" },
250 { Opt_sec_ntlmssp, "ntlmssp" },
251 { Opt_ntlm, "ntlm" },
252 { Opt_sec_ntlmi, "ntlmi" },
Jeff Layton76596242012-07-23 20:34:17 -0400253 { Opt_sec_ntlmv2, "nontlm" },
254 { Opt_sec_ntlmv2, "ntlmv2" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400255 { Opt_sec_ntlmv2i, "ntlmv2i" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400256 { Opt_sec_lanman, "lanman" },
257 { Opt_sec_none, "none" },
258
259 { Opt_sec_err, NULL }
260};
261
Jeff Layton15b6a472012-05-16 07:50:15 -0400262/* cache flavors */
263enum {
264 Opt_cache_loose,
265 Opt_cache_strict,
266 Opt_cache_none,
267 Opt_cache_err
268};
269
270static const match_table_t cifs_cacheflavor_tokens = {
271 { Opt_cache_loose, "loose" },
272 { Opt_cache_strict, "strict" },
273 { Opt_cache_none, "none" },
274 { Opt_cache_err, NULL }
275};
276
Jeff Layton23db65f2012-05-15 12:20:51 -0400277static const match_table_t cifs_smb_version_tokens = {
278 { Smb_1, SMB1_VERSION_STRING },
Steve Frenchdd446b12012-11-28 23:21:06 -0600279 { Smb_20, SMB20_VERSION_STRING},
Steve French1080ef72011-02-24 18:07:19 +0000280 { Smb_21, SMB21_VERSION_STRING },
Steve Frenche4aa25e2012-10-01 12:26:22 -0500281 { Smb_30, SMB30_VERSION_STRING },
Steve French20b6d8b2013-06-12 22:48:41 -0500282 { Smb_302, SMB302_VERSION_STRING },
Jeff Layton23db65f2012-05-15 12:20:51 -0400283};
284
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300285static int ip_connect(struct TCP_Server_Info *server);
286static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400287static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400288static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400289static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
290 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Jeff Laytond5c56052008-12-01 18:42:33 -0500292/*
293 * cifs tcp session reconnection
294 *
295 * mark tcp session as reconnecting so temporarily locked
296 * mark all smb sessions as reconnecting for tcp session
297 * reconnect tcp session
298 * wake up waiters on reconnection? - (not needed currently)
299 */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400300int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301cifs_reconnect(struct TCP_Server_Info *server)
302{
303 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500304 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000305 struct cifs_ses *ses;
306 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000307 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400308 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000311 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000312 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 next time through the loop */
314 spin_unlock(&GlobalMid_Lock);
315 return rc;
316 } else
317 server->tcpStatus = CifsNeedReconnect;
318 spin_unlock(&GlobalMid_Lock);
319 server->maxBuf = 0;
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400320#ifdef CONFIG_CIFS_SMB2
321 server->max_read = 0;
322#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
Joe Perchesf96637b2013-05-04 22:12:25 -0500324 cifs_dbg(FYI, "Reconnecting tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 /* before reconnecting the tcp session, mark the smb session (uid)
327 and the tid bad so they are not used until reconnected */
Joe Perchesf96637b2013-05-04 22:12:25 -0500328 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
329 __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530330 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500331 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000332 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500333 ses->need_reconnect = true;
334 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500335 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000336 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500337 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530340 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 /* do not want to be sending data on a socket we are freeing */
Joe Perchesf96637b2013-05-04 22:12:25 -0500343 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500344 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000345 if (server->ssocket) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500346 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
347 server->ssocket->state, server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800348 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesf96637b2013-05-04 22:12:25 -0500349 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
350 server->ssocket->state, server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 sock_release(server->ssocket);
352 server->ssocket = NULL;
353 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500354 server->sequence_number = 0;
355 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500356 kfree(server->session_key.response);
357 server->session_key.response = NULL;
358 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000359 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500360 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500362 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400363 INIT_LIST_HEAD(&retry_list);
Joe Perchesf96637b2013-05-04 22:12:25 -0500364 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500366 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
367 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400368 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
369 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400370 list_move(&mid_entry->qhead, &retry_list);
371 }
372 spin_unlock(&GlobalMid_Lock);
373
Joe Perchesf96637b2013-05-04 22:12:25 -0500374 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400375 list_for_each_safe(tmp, tmp2, &retry_list) {
376 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500377 list_del_init(&mid_entry->qhead);
378 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400381 do {
Steve French6c3d8902006-07-31 22:46:20 +0000382 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300383
384 /* we should try only the port we connected to before */
Jeff Layton73e216a2013-09-05 08:38:10 -0400385 mutex_lock(&server->srv_mutex);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300386 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000387 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500388 cifs_dbg(FYI, "reconnect error %d\n", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700389 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 } else {
391 atomic_inc(&tcpSesReconnectCount);
392 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000393 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000394 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000395 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
Jeff Layton73e216a2013-09-05 08:38:10 -0400397 mutex_unlock(&server->srv_mutex);
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400398 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 return rc;
401}
402
Jeff Laytonc74093b2011-01-11 07:24:23 -0500403static void
404cifs_echo_request(struct work_struct *work)
405{
406 int rc;
407 struct TCP_Server_Info *server = container_of(work,
408 struct TCP_Server_Info, echo.work);
409
Jeff Layton247ec9b2011-02-04 17:09:50 -0500410 /*
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400411 * We cannot send an echo if it is disabled or until the
412 * NEGOTIATE_PROTOCOL request is done, which is indicated by
413 * server->ops->need_neg() == true. Also, no need to ping if
414 * we got a response recently.
Jeff Layton247ec9b2011-02-04 17:09:50 -0500415 */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400416 if (!server->ops->need_neg || server->ops->need_neg(server) ||
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400417 (server->ops->can_echo && !server->ops->can_echo(server)) ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500418 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500419 goto requeue_echo;
420
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400421 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500422 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500423 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
424 server->hostname);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500425
426requeue_echo:
Jeff Laytonda472fc2012-03-23 14:40:53 -0400427 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500428}
429
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400430static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400431allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400432{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400433 if (!server->bigbuf) {
434 server->bigbuf = (char *)cifs_buf_get();
435 if (!server->bigbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500436 cifs_dbg(VFS, "No memory for large SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400437 msleep(3000);
438 /* retry will check if exiting */
439 return false;
440 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400441 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400442 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400443 memset(server->bigbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400444 }
445
Jeff Layton2a37ef92011-10-19 15:29:23 -0400446 if (!server->smallbuf) {
447 server->smallbuf = (char *)cifs_small_buf_get();
448 if (!server->smallbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500449 cifs_dbg(VFS, "No memory for SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400450 msleep(1000);
451 /* retry will check if exiting */
452 return false;
453 }
454 /* beginning of smb buffer is cleared in our buf_get */
455 } else {
456 /* if existing small buf clear beginning */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400457 memset(server->smallbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400458 }
459
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400460 return true;
461}
462
Jeff Laytonba749e62011-10-11 06:41:32 -0400463static bool
464server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400465{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300466 /*
467 * We need to wait 2 echo intervals to make sure we handle such
468 * situations right:
469 * 1s client sends a normal SMB request
470 * 2s client gets a response
471 * 30s echo workqueue job pops, and decides we got a response recently
472 * and don't need to send another
473 * ...
474 * 65s kernel_recvmsg times out, and we see that we haven't gotten
475 * a response in >60s.
476 */
477 if (server->tcpStatus == CifsGood &&
478 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500479 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
480 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400481 cifs_reconnect(server);
482 wake_up(&server->response_q);
483 return true;
484 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400485
Jeff Laytonba749e62011-10-11 06:41:32 -0400486 return false;
487}
488
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400489/*
490 * kvec_array_init - clone a kvec array, and advance into it
491 * @new: pointer to memory for cloned array
492 * @iov: pointer to original array
493 * @nr_segs: number of members in original array
494 * @bytes: number of bytes to advance into the cloned array
495 *
496 * This function will copy the array provided in iov to a section of memory
497 * and advance the specified number of bytes into the new array. It returns
498 * the number of segments in the new array. "new" must be at least as big as
499 * the original iov array.
500 */
501static unsigned int
502kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
503 size_t bytes)
504{
505 size_t base = 0;
506
507 while (bytes || !iov->iov_len) {
508 int copy = min(bytes, iov->iov_len);
509
510 bytes -= copy;
511 base += copy;
512 if (iov->iov_len == base) {
513 iov++;
514 nr_segs--;
515 base = 0;
516 }
517 }
518 memcpy(new, iov, sizeof(*iov) * nr_segs);
519 new->iov_base += base;
520 new->iov_len -= base;
521 return nr_segs;
522}
523
Jeff Layton1041e3f2011-10-19 15:28:27 -0400524static struct kvec *
525get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
526{
527 struct kvec *new_iov;
528
529 if (server->iov && nr_segs <= server->nr_iov)
530 return server->iov;
531
532 /* not big enough -- allocate a new one and release the old */
533 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
534 if (new_iov) {
535 kfree(server->iov);
536 server->iov = new_iov;
537 server->nr_iov = nr_segs;
538 }
539 return new_iov;
540}
541
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400542int
543cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
544 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400545{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400546 int length = 0;
547 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400548 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400549 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400550 struct kvec *iov;
551
Jeff Layton1041e3f2011-10-19 15:28:27 -0400552 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400553 if (!iov)
554 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400555
Jeff Laytone831e6c2011-10-11 06:41:32 -0400556 smb_msg.msg_control = NULL;
557 smb_msg.msg_controllen = 0;
558
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400559 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500560 try_to_freeze();
561
Jeff Laytonba749e62011-10-11 06:41:32 -0400562 if (server_unresponsive(server)) {
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400563 total_read = -ECONNABORTED;
Jeff Laytonba749e62011-10-11 06:41:32 -0400564 break;
565 }
566
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400567 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
568
569 length = kernel_recvmsg(server->ssocket, &smb_msg,
570 iov, segs, to_read, 0);
571
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400572 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400573 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400574 break;
575 } else if (server->tcpStatus == CifsNeedReconnect) {
576 cifs_reconnect(server);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400577 total_read = -ECONNABORTED;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400578 break;
579 } else if (length == -ERESTARTSYS ||
580 length == -EAGAIN ||
581 length == -EINTR) {
582 /*
583 * Minimum sleep to prevent looping, allowing socket
584 * to clear and app threads to set tcpStatus
585 * CifsNeedReconnect if server hung.
586 */
587 usleep_range(1000, 2000);
588 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400589 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400590 } else if (length <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500591 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
592 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400593 cifs_reconnect(server);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400594 total_read = -ECONNABORTED;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400595 break;
596 }
597 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400598 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400599}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400600
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400601int
602cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
603 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400604{
605 struct kvec iov;
606
607 iov.iov_base = buf;
608 iov.iov_len = to_read;
609
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400610 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400611}
612
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400613static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400614is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400615{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400616 /*
617 * The first byte big endian of the length field,
618 * is actually not part of the length but the type
619 * with the most common, zero, as regular data.
620 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400621 switch (type) {
622 case RFC1002_SESSION_MESSAGE:
623 /* Regular SMB response */
624 return true;
625 case RFC1002_SESSION_KEEP_ALIVE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500626 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400627 break;
628 case RFC1002_POSITIVE_SESSION_RESPONSE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500629 cifs_dbg(FYI, "RFC 1002 positive session response\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400630 break;
631 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400632 /*
633 * We get this from Windows 98 instead of an error on
634 * SMB negprot response.
635 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500636 cifs_dbg(FYI, "RFC 1002 negative session response\n");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400637 /* give server a second to clean up */
638 msleep(1000);
639 /*
640 * Always try 445 first on reconnect since we get NACK
641 * on some if we ever connected to port 139 (the NACK
642 * is since we do not begin with RFC1001 session
643 * initialize frame).
644 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400645 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400646 cifs_reconnect(server);
647 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400648 break;
649 default:
Joe Perchesf96637b2013-05-04 22:12:25 -0500650 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400651 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400652 }
653
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400654 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400655}
656
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400657void
658dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400659{
660#ifdef CONFIG_CIFS_STATS2
661 mid->when_received = jiffies;
662#endif
663 spin_lock(&GlobalMid_Lock);
664 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400665 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400666 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400667 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400668 list_del_init(&mid->qhead);
669 spin_unlock(&GlobalMid_Lock);
670}
671
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400672static void
673handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400674 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400675{
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400676 if (server->ops->check_trans2 &&
677 server->ops->check_trans2(mid, server, buf, malformed))
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400678 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400679 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400680 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400681 /* Was previous buf put in mpx struct for multi-rsp? */
682 if (!mid->multiRsp) {
683 /* smb buffer will be freed by user thread */
684 if (server->large_buf)
685 server->bigbuf = NULL;
686 else
687 server->smallbuf = NULL;
688 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400689 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400690}
691
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400692static void clean_demultiplex_info(struct TCP_Server_Info *server)
693{
694 int length;
695
696 /* take it off the list, if it's not already */
697 spin_lock(&cifs_tcp_ses_lock);
698 list_del_init(&server->tcp_ses_list);
699 spin_unlock(&cifs_tcp_ses_lock);
700
701 spin_lock(&GlobalMid_Lock);
702 server->tcpStatus = CifsExiting;
703 spin_unlock(&GlobalMid_Lock);
704 wake_up_all(&server->response_q);
705
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400706 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300707 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400708 if (server->credits <= 0)
709 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300710 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400711 /*
712 * Although there should not be any requests blocked on this queue it
713 * can not hurt to be paranoid and try to wake up requests that may
714 * haven been blocked when more than 50 at time were on the wire to the
715 * same server - they now will see the session is in exit state and get
716 * out of SendReceive.
717 */
718 wake_up_all(&server->request_q);
719 /* give those requests time to exit */
720 msleep(125);
721
722 if (server->ssocket) {
723 sock_release(server->ssocket);
724 server->ssocket = NULL;
725 }
726
727 if (!list_empty(&server->pending_mid_q)) {
728 struct list_head dispose_list;
729 struct mid_q_entry *mid_entry;
730 struct list_head *tmp, *tmp2;
731
732 INIT_LIST_HEAD(&dispose_list);
733 spin_lock(&GlobalMid_Lock);
734 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
735 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500736 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400737 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400738 list_move(&mid_entry->qhead, &dispose_list);
739 }
740 spin_unlock(&GlobalMid_Lock);
741
742 /* now walk dispose list and issue callbacks */
743 list_for_each_safe(tmp, tmp2, &dispose_list) {
744 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500745 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400746 list_del_init(&mid_entry->qhead);
747 mid_entry->callback(mid_entry);
748 }
749 /* 1/8th of sec is more than enough time for them to exit */
750 msleep(125);
751 }
752
753 if (!list_empty(&server->pending_mid_q)) {
754 /*
755 * mpx threads have not exited yet give them at least the smb
756 * send timeout time for long ops.
757 *
758 * Due to delays on oplock break requests, we need to wait at
759 * least 45 seconds before giving up on a request getting a
760 * response and going ahead and killing cifsd.
761 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500762 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400763 msleep(46000);
764 /*
765 * If threads still have not exited they are probably never
766 * coming home not much else we can do but free the memory.
767 */
768 }
769
770 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400771 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400772 kfree(server);
773
774 length = atomic_dec_return(&tcpSesAllocCount);
775 if (length > 0)
776 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
777 GFP_KERNEL);
778}
779
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400780static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400781standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
782{
783 int length;
784 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400785 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400786
787 /* make sure this will fit in a large buffer */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400788 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500789 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400790 cifs_reconnect(server);
791 wake_up(&server->response_q);
Pavel Shilovsky3fabaa22014-07-10 09:55:52 +0400792 return -ECONNABORTED;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400793 }
794
795 /* switch to large buffer if too big for a small one */
796 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
797 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400798 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400799 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400800 }
801
802 /* now read the rest */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400803 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
804 pdu_length - HEADER_SIZE(server) + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400805 if (length < 0)
806 return length;
807 server->total_read += length;
808
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400809 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400810
811 /*
812 * We know that we received enough to get to the MID as we
813 * checked the pdu_length earlier. Now check to see
814 * if the rest of the header is OK. We borrow the length
815 * var for the rest of the loop to avoid a new stack var.
816 *
817 * 48 bytes is enough to display the header and a little bit
818 * into the payload for debugging purposes.
819 */
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400820 length = server->ops->check_message(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400821 if (length != 0)
822 cifs_dump_mem("Bad SMB: ", buf,
823 min_t(unsigned int, server->total_read, 48));
824
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700825 if (server->ops->is_status_pending &&
826 server->ops->is_status_pending(buf, server, length))
827 return -1;
828
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500829 if (!mid)
830 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400831
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400832 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500833 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400834}
835
836static int
Al Viro7c97c202011-06-21 08:51:28 -0400837cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
839 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400840 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400841 unsigned int pdu_length;
842 char *buf = NULL;
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500843 struct task_struct *task_to_wake = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 current->flags |= PF_MEMALLOC;
Joe Perchesf96637b2013-05-04 22:12:25 -0500847 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400848
849 length = atomic_inc_return(&tcpSesAllocCount);
850 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000851 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
852 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700854 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000855 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700856 if (try_to_freeze())
857 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700858
Jeff Layton2a37ef92011-10-19 15:29:23 -0400859 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400860 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700861
Jeff Layton2a37ef92011-10-19 15:29:23 -0400862 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400863 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000864 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000865
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400866 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400867 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000868 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400869 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700870
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400871 /*
872 * The right amount was read from socket - 4 bytes,
873 * so we can now interpret the length field.
874 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400875 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -0700876
Joe Perchesf96637b2013-05-04 22:12:25 -0500877 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400878 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000879 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700880
Jeff Layton89482a52011-10-19 15:28:57 -0400881 /* make sure we have enough to get to the MID */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400882 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500883 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
884 pdu_length);
Jeff Layton89482a52011-10-19 15:28:57 -0400885 cifs_reconnect(server);
886 wake_up(&server->response_q);
887 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700888 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400889
Jeff Layton89482a52011-10-19 15:28:57 -0400890 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400891 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400892 HEADER_SIZE(server) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400893 if (length < 0)
894 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400895 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400896
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400897 mid_entry = server->ops->find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400898
Jeff Layton44d22d82011-10-19 15:29:49 -0400899 if (!mid_entry || !mid_entry->receive)
900 length = standard_receive3(server, mid_entry);
901 else
902 length = mid_entry->receive(server, mid_entry);
903
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400904 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700905 continue;
906
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400907 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -0400908 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700909
Steve Frenchfda35942011-01-20 18:06:34 +0000910 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500911 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400912 if (!mid_entry->multiRsp || mid_entry->multiEnd)
913 mid_entry->callback(mid_entry);
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400914 } else if (!server->ops->is_oplock_break ||
915 !server->ops->is_oplock_break(buf, server)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500916 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
917 atomic_read(&midCount));
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400918 cifs_dump_mem("Received Data is: ", buf,
919 HEADER_SIZE(server));
Steve French39798772006-05-31 22:40:51 +0000920#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400921 if (server->ops->dump_detail)
922 server->ops->dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +0000923 cifs_dump_mids(server);
924#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000925
Steve Frenche4eb2952005-04-28 22:41:09 -0700926 }
927 } /* end while !EXITING */
928
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800929 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400930 cifs_buf_release(server->bigbuf);
931 if (server->smallbuf) /* no sense logging a debug message if NULL */
932 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500934 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400935 clean_demultiplex_info(server);
Steve Frencha5c3e1c2014-09-16 04:16:19 -0500936
937 /* if server->tsk was NULL then wait for a signal before exiting */
938 if (!task_to_wake) {
939 set_current_state(TASK_INTERRUPTIBLE);
940 while (!signal_pending(current)) {
941 schedule();
942 set_current_state(TASK_INTERRUPTIBLE);
943 }
944 set_current_state(TASK_RUNNING);
945 }
946
Jeff Layton0468a2c2008-12-01 07:09:35 -0500947 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948}
949
Jeff Laytonc359cf32007-11-16 22:22:06 +0000950/* extract the host portion of the UNC string */
951static char *
952extract_hostname(const char *unc)
953{
954 const char *src;
955 char *dst, *delim;
956 unsigned int len;
957
958 /* skip double chars at beginning of string */
959 /* BB: check validity of these bytes? */
960 src = unc + 2;
961
962 /* delimiter between hostname and sharename is always '\\' now */
963 delim = strchr(src, '\\');
964 if (!delim)
965 return ERR_PTR(-EINVAL);
966
967 len = delim - src;
968 dst = kmalloc((len + 1), GFP_KERNEL);
969 if (dst == NULL)
970 return ERR_PTR(-ENOMEM);
971
972 memcpy(dst, src, len);
973 dst[len] = '\0';
974
975 return dst;
976}
977
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400978static int get_option_ul(substring_t args[], unsigned long *option)
979{
980 int rc;
981 char *string;
982
983 string = match_strdup(args);
984 if (string == NULL)
985 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +0100986 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400987 kfree(string);
988
989 return rc;
990}
991
Eric W. Biederman3da46562013-02-06 01:37:39 -0800992static int get_option_uid(substring_t args[], kuid_t *result)
993{
994 unsigned long value;
995 kuid_t uid;
996 int rc;
997
998 rc = get_option_ul(args, &value);
999 if (rc)
1000 return rc;
1001
1002 uid = make_kuid(current_user_ns(), value);
1003 if (!uid_valid(uid))
1004 return -EINVAL;
1005
1006 *result = uid;
1007 return 0;
1008}
1009
1010static int get_option_gid(substring_t args[], kgid_t *result)
1011{
1012 unsigned long value;
1013 kgid_t gid;
1014 int rc;
1015
1016 rc = get_option_ul(args, &value);
1017 if (rc)
1018 return rc;
1019
1020 gid = make_kgid(current_user_ns(), value);
1021 if (!gid_valid(gid))
1022 return -EINVAL;
1023
1024 *result = gid;
1025 return 0;
1026}
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001027
1028static int cifs_parse_security_flavors(char *value,
1029 struct smb_vol *vol)
1030{
1031
1032 substring_t args[MAX_OPT_ARGS];
1033
Jeff Layton1e3cc572013-06-10 17:12:23 -05001034 /*
1035 * With mount options, the last one should win. Reset any existing
1036 * settings back to default.
1037 */
1038 vol->sectype = Unspecified;
1039 vol->sign = false;
1040
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001041 switch (match_token(value, cifs_secflavor_tokens, args)) {
Jeff Layton3f618222013-06-12 19:52:14 -05001042 case Opt_sec_krb5p:
1043 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1044 return 1;
1045 case Opt_sec_krb5i:
1046 vol->sign = true;
1047 /* Fallthrough */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001048 case Opt_sec_krb5:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001049 vol->sectype = Kerberos;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001050 break;
1051 case Opt_sec_ntlmsspi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001052 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001053 /* Fallthrough */
1054 case Opt_sec_ntlmssp:
1055 vol->sectype = RawNTLMSSP;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001056 break;
1057 case Opt_sec_ntlmi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001058 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001059 /* Fallthrough */
1060 case Opt_ntlm:
1061 vol->sectype = NTLM;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001062 break;
1063 case Opt_sec_ntlmv2i:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001064 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001065 /* Fallthrough */
1066 case Opt_sec_ntlmv2:
1067 vol->sectype = NTLMv2;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001068 break;
1069#ifdef CONFIG_CIFS_WEAK_PW_HASH
1070 case Opt_sec_lanman:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001071 vol->sectype = LANMAN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001072 break;
1073#endif
1074 case Opt_sec_none:
1075 vol->nullauth = 1;
1076 break;
1077 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001078 cifs_dbg(VFS, "bad security option: %s\n", value);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001079 return 1;
1080 }
1081
1082 return 0;
1083}
1084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085static int
Jeff Layton15b6a472012-05-16 07:50:15 -04001086cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1087{
1088 substring_t args[MAX_OPT_ARGS];
1089
1090 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1091 case Opt_cache_loose:
1092 vol->direct_io = false;
1093 vol->strict_io = false;
1094 break;
1095 case Opt_cache_strict:
1096 vol->direct_io = false;
1097 vol->strict_io = true;
1098 break;
1099 case Opt_cache_none:
1100 vol->direct_io = true;
1101 vol->strict_io = false;
1102 break;
1103 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001104 cifs_dbg(VFS, "bad cache= option: %s\n", value);
Jeff Layton15b6a472012-05-16 07:50:15 -04001105 return 1;
1106 }
1107 return 0;
1108}
1109
1110static int
Jeff Layton23db65f2012-05-15 12:20:51 -04001111cifs_parse_smb_version(char *value, struct smb_vol *vol)
1112{
1113 substring_t args[MAX_OPT_ARGS];
1114
1115 switch (match_token(value, cifs_smb_version_tokens, args)) {
1116 case Smb_1:
1117 vol->ops = &smb1_operations;
1118 vol->vals = &smb1_values;
1119 break;
Steve French1080ef72011-02-24 18:07:19 +00001120#ifdef CONFIG_CIFS_SMB2
Steve Frenchdd446b12012-11-28 23:21:06 -06001121 case Smb_20:
Pavel Shilovsky53ef1012013-09-05 16:11:28 +04001122 vol->ops = &smb20_operations;
Steve Frenchdd446b12012-11-28 23:21:06 -06001123 vol->vals = &smb20_values;
1124 break;
Steve French1080ef72011-02-24 18:07:19 +00001125 case Smb_21:
1126 vol->ops = &smb21_operations;
1127 vol->vals = &smb21_values;
1128 break;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001129 case Smb_30:
Steve French38107d42012-12-08 22:08:06 -06001130 vol->ops = &smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001131 vol->vals = &smb30_values;
1132 break;
Steve French20b6d8b2013-06-12 22:48:41 -05001133 case Smb_302:
1134 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1135 vol->vals = &smb302_values;
1136 break;
Steve French1080ef72011-02-24 18:07:19 +00001137#endif
Jeff Layton23db65f2012-05-15 12:20:51 -04001138 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001139 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
Jeff Layton23db65f2012-05-15 12:20:51 -04001140 return 1;
1141 }
1142 return 0;
1143}
1144
Jeff Laytond387a5c2012-12-10 06:10:46 -05001145/*
1146 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1147 * fields with the result. Returns 0 on success and an error otherwise.
1148 */
1149static int
1150cifs_parse_devname(const char *devname, struct smb_vol *vol)
1151{
1152 char *pos;
1153 const char *delims = "/\\";
1154 size_t len;
1155
1156 /* make sure we have a valid UNC double delimiter prefix */
1157 len = strspn(devname, delims);
1158 if (len != 2)
1159 return -EINVAL;
1160
1161 /* find delimiter between host and sharename */
1162 pos = strpbrk(devname + 2, delims);
1163 if (!pos)
1164 return -EINVAL;
1165
1166 /* skip past delimiter */
1167 ++pos;
1168
1169 /* now go until next delimiter or end of string */
1170 len = strcspn(pos, delims);
1171
1172 /* move "pos" up to delimiter or NULL */
1173 pos += len;
1174 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1175 if (!vol->UNC)
1176 return -ENOMEM;
1177
1178 convert_delimiter(vol->UNC, '\\');
1179
1180 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1181 if (!*pos++ || !*pos)
1182 return 0;
1183
1184 vol->prepath = kstrdup(pos, GFP_KERNEL);
1185 if (!vol->prepath)
1186 return -ENOMEM;
1187
1188 return 0;
1189}
1190
Jeff Layton23db65f2012-05-15 12:20:51 -04001191static int
Sean Finneyb9468452011-04-11 13:19:32 +00001192cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001193 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001195 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001196 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 unsigned int temp_len, i, j;
1198 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001199 short int override_uid = -1;
1200 short int override_gid = -1;
1201 bool uid_specified = false;
1202 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001203 bool sloppy = false;
1204 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001205 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001206 char *string = NULL;
1207 char *tmp_end, *value;
1208 char delim;
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001209 bool got_ip = false;
1210 unsigned short port = 0;
1211 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
1213 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001214 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001215 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
Jeff Layton6ee95422012-11-26 11:09:57 -05001217 /* ensure we always start with zeroed-out smb_vol */
1218 memset(vol, 0, sizeof(*vol));
1219
Jeff Layton88463992010-11-22 15:31:03 -05001220 /*
1221 * does not have to be perfect mapping since field is
1222 * informational, only used for servers that do not support
1223 * port 445 and it can be overridden at mount time
1224 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001225 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1226 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001227 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1228
Jeff Layton1397f2e2011-01-07 11:30:28 -05001229 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001230 /* null target name indicates to use *SMBSERVR default called name
1231 if we end up sending RFC1001 session initialize */
1232 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001233 vol->cred_uid = current_uid();
1234 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001235 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001236
Steve French2baa2682014-09-27 02:19:01 -05001237 /*
1238 * default to SFM style remapping of seven reserved characters
1239 * unless user overrides it or we negotiate CIFS POSIX where
1240 * it is unnecessary. Can not simultaneously use more than one mapping
1241 * since then readdir could list files that open could not open
1242 */
1243 vol->remap = true;
1244
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001245 /* default to only allowing write access to owner of the mount */
1246 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
1248 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001249 /* default is always to request posix paths. */
1250 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001251 /* default to using server inode numbers where available */
1252 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001253
Jeff Layton1b359202012-09-19 15:20:27 -07001254 /* default is to use strict cifs caching semantics */
1255 vol->strict_io = true;
1256
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301257 vol->actimeo = CIFS_DEF_ACTIMEO;
1258
Jeff Layton23db65f2012-05-15 12:20:51 -04001259 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1260 vol->ops = &smb1_operations;
1261 vol->vals = &smb1_values;
1262
Sean Finneyb9468452011-04-11 13:19:32 +00001263 if (!mountdata)
1264 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Sean Finneyb9468452011-04-11 13:19:32 +00001266 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1267 if (!mountdata_copy)
1268 goto cifs_parse_mount_err;
1269
1270 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001271 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001272
Steve French50c2f752007-07-13 00:33:32 +00001273 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001274 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 separator[0] = options[4];
1276 options += 5;
1277 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001278 cifs_dbg(FYI, "Null separator not allowed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
1280 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001281 vol->backupuid_specified = false; /* no backup intent for a user */
1282 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001283
Jeff Layton37d4f992013-05-24 07:40:05 -04001284 switch (cifs_parse_devname(devname, vol)) {
1285 case 0:
1286 break;
1287 case -ENOMEM:
1288 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1289 goto cifs_parse_mount_err;
1290 case -EINVAL:
1291 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1292 goto cifs_parse_mount_err;
1293 default:
1294 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1295 goto cifs_parse_mount_err;
Jeff Laytond387a5c2012-12-10 06:10:46 -05001296 }
1297
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001299 substring_t args[MAX_OPT_ARGS];
1300 unsigned long option;
1301 int token;
1302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (!*data)
1304 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001306 token = match_token(data, cifs_mount_option_tokens, args);
1307
1308 switch (token) {
1309
1310 /* Ingnore the following */
1311 case Opt_ignore:
1312 break;
1313
1314 /* Boolean values */
1315 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001317 break;
1318 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001320 break;
1321 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001322 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001323 break;
1324 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001325 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001326 break;
Jeff Layton72bd4812012-10-03 16:02:36 -04001327 case Opt_forcegid:
1328 override_gid = 1;
1329 break;
1330 case Opt_noforcegid:
1331 override_gid = 0;
1332 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001333 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001334 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001335 break;
1336 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001337 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001338 break;
1339 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001341 break;
1342 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001344 break;
1345 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001347 break;
1348 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001350 break;
1351 case Opt_mapchars:
Steve French2baa2682014-09-27 02:19:01 -05001352 vol->sfu_remap = true;
1353 vol->remap = false; /* disable SFM mapping */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001354 break;
1355 case Opt_nomapchars:
Steve French2baa2682014-09-27 02:19:01 -05001356 vol->sfu_remap = false;
1357 break;
1358 case Opt_mapposix:
1359 vol->remap = true;
1360 vol->sfu_remap = false; /* disable SFU mapping */
1361 break;
1362 case Opt_nomapposix:
1363 vol->remap = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001364 break;
1365 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001366 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001367 break;
1368 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001369 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001370 break;
1371 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001372 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001373 break;
1374 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001375 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001376 break;
1377 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001378 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001379 break;
1380 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001381 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001382 break;
1383 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001384 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001385 break;
1386 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001387 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001388 break;
1389 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001390 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001391 /*
1392 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001393 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001394 * local vfs will do advisory
1395 */
Steve French50c2f752007-07-13 00:33:32 +00001396 if (vol->file_mode ==
1397 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001398 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001399 break;
1400 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001401 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001402 break;
1403 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001405 break;
1406 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001408 break;
1409 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001410 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001411 break;
1412 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001413 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001414 break;
1415 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001417 break;
1418 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001420 break;
1421 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001423 break;
1424 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001426 break;
1427 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001428 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001429 break;
1430 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001431 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001432 break;
1433 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001435 break;
1436 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001438 break;
1439 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001440 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001441 break;
1442 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001443 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001444 break;
1445 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001446 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001447 break;
1448 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001450 break;
1451 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001453 break;
1454 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001455 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001456 break;
1457 case Opt_sign:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001458 vol->sign = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001459 break;
1460 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001461 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001462 * is a per tree connection (mount) not a per socket
1463 * or per-smb connection option in the protocol
1464 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1465 */
Steve French95b1cb92008-05-15 16:44:38 +00001466 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001467 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001468 case Opt_noac:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001469 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001470 break;
1471 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301472#ifndef CONFIG_CIFS_FSCACHE
Joe Perchesf96637b2013-05-04 22:12:25 -05001473 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001474 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301475#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301476 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001477 break;
1478 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001479 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001480 break;
1481 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001482 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001483 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001484 case Opt_sloppy:
1485 sloppy = true;
1486 break;
Jeff Laytona0b3df52013-05-24 07:40:59 -04001487 case Opt_nosharesock:
1488 vol->nosharesock = true;
1489 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001490
1491 /* Numeric Values */
1492 case Opt_backupuid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001493 if (get_option_uid(args, &vol->backupuid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001494 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1495 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001496 goto cifs_parse_mount_err;
1497 }
1498 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001499 break;
1500 case Opt_backupgid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001501 if (get_option_gid(args, &vol->backupgid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001502 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1503 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001504 goto cifs_parse_mount_err;
1505 }
1506 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001507 break;
1508 case Opt_uid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001509 if (get_option_uid(args, &vol->linux_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001510 cifs_dbg(VFS, "%s: Invalid uid value\n",
1511 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001512 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001514 uid_specified = true;
1515 break;
1516 case Opt_cruid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001517 if (get_option_uid(args, &vol->cred_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001518 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1519 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001520 goto cifs_parse_mount_err;
1521 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001522 break;
1523 case Opt_gid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001524 if (get_option_gid(args, &vol->linux_gid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001525 cifs_dbg(VFS, "%s: Invalid gid value\n",
1526 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001527 goto cifs_parse_mount_err;
1528 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001529 gid_specified = true;
1530 break;
1531 case Opt_file_mode:
1532 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001533 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1534 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001535 goto cifs_parse_mount_err;
1536 }
1537 vol->file_mode = option;
1538 break;
1539 case Opt_dirmode:
1540 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001541 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1542 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001543 goto cifs_parse_mount_err;
1544 }
1545 vol->dir_mode = option;
1546 break;
1547 case Opt_port:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001548 if (get_option_ul(args, &option) ||
1549 option > USHRT_MAX) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001550 cifs_dbg(VFS, "%s: Invalid port value\n",
1551 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001552 goto cifs_parse_mount_err;
1553 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001554 port = (unsigned short)option;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001555 break;
1556 case Opt_rsize:
1557 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001558 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1559 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001560 goto cifs_parse_mount_err;
1561 }
1562 vol->rsize = option;
1563 break;
1564 case Opt_wsize:
1565 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001566 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1567 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001568 goto cifs_parse_mount_err;
1569 }
1570 vol->wsize = option;
1571 break;
1572 case Opt_actimeo:
1573 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001574 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1575 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001576 goto cifs_parse_mount_err;
1577 }
1578 vol->actimeo = HZ * option;
1579 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001580 cifs_dbg(VFS, "attribute cache timeout too large\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001581 goto cifs_parse_mount_err;
1582 }
1583 break;
1584
1585 /* String Arguments */
1586
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001587 case Opt_blank_user:
1588 /* null user, ie. anonymous authentication */
1589 vol->nullauth = 1;
1590 vol->username = NULL;
1591 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001592 case Opt_user:
1593 string = match_strdup(args);
1594 if (string == NULL)
1595 goto out_nomem;
1596
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04001597 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1598 CIFS_MAX_USERNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001599 pr_warn("CIFS: username too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001600 goto cifs_parse_mount_err;
1601 }
1602 vol->username = kstrdup(string, GFP_KERNEL);
Joe Perchesf96637b2013-05-04 22:12:25 -05001603 if (!vol->username)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001604 goto cifs_parse_mount_err;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001605 break;
1606 case Opt_blank_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001607 /* passwords have to be handled differently
1608 * to allow the character used for deliminator
1609 * to be passed within them
1610 */
1611
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001612 /*
1613 * Check if this is a case where the password
1614 * starts with a delimiter
1615 */
1616 tmp_end = strchr(data, '=');
1617 tmp_end++;
1618 if (!(tmp_end < end && tmp_end[1] == delim)) {
1619 /* No it is not. Set the password to NULL */
Namjae Jeond6ccf492014-08-21 19:11:20 +09001620 kfree(vol->password);
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001621 vol->password = NULL;
1622 break;
1623 }
1624 /* Yes it is. Drop down to Opt_pass below.*/
1625 case Opt_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001626 /* Obtain the value string */
1627 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001628 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001629
1630 /* Set tmp_end to end of the string */
1631 tmp_end = (char *) value + strlen(value);
1632
1633 /* Check if following character is the deliminator
1634 * If yes, we have encountered a double deliminator
1635 * reset the NULL character to the deliminator
1636 */
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301637 if (tmp_end < end && tmp_end[1] == delim) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001638 tmp_end[0] = delim;
1639
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301640 /* Keep iterating until we get to a single
1641 * deliminator OR the end
1642 */
1643 while ((tmp_end = strchr(tmp_end, delim))
1644 != NULL && (tmp_end[1] == delim)) {
1645 tmp_end = (char *) &tmp_end[2];
1646 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001647
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301648 /* Reset var options to point to next element */
1649 if (tmp_end) {
1650 tmp_end[0] = '\0';
1651 options = (char *) &tmp_end[1];
1652 } else
1653 /* Reached the end of the mount option
1654 * string */
1655 options = end;
1656 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001657
Namjae Jeond6ccf492014-08-21 19:11:20 +09001658 kfree(vol->password);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001659 /* Now build new password string */
1660 temp_len = strlen(value);
1661 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1662 if (vol->password == NULL) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001663 pr_warn("CIFS: no memory for password\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001664 goto cifs_parse_mount_err;
1665 }
1666
1667 for (i = 0, j = 0; i < temp_len; i++, j++) {
1668 vol->password[j] = value[i];
1669 if ((value[i] == delim) &&
1670 value[i+1] == delim)
1671 /* skip the second deliminator */
1672 i++;
1673 }
1674 vol->password[j] = '\0';
1675 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001676 case Opt_blank_ip:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001677 /* FIXME: should this be an error instead? */
1678 got_ip = false;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001679 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001680 case Opt_ip:
1681 string = match_strdup(args);
1682 if (string == NULL)
1683 goto out_nomem;
1684
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001685 if (!cifs_convert_address(dstaddr, string,
1686 strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001687 pr_err("CIFS: bad ip= option (%s).\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001688 goto cifs_parse_mount_err;
1689 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001690 got_ip = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001691 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001692 case Opt_domain:
1693 string = match_strdup(args);
1694 if (string == NULL)
1695 goto out_nomem;
1696
Chen Gang057d6332013-07-19 09:01:36 +08001697 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1698 == CIFS_MAX_DOMAINNAME_LEN) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001699 pr_warn("CIFS: domain name too long\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001700 goto cifs_parse_mount_err;
1701 }
1702
1703 vol->domainname = kstrdup(string, GFP_KERNEL);
1704 if (!vol->domainname) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001705 pr_warn("CIFS: no memory for domainname\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001706 goto cifs_parse_mount_err;
1707 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001708 cifs_dbg(FYI, "Domain name set\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001709 break;
1710 case Opt_srcaddr:
1711 string = match_strdup(args);
1712 if (string == NULL)
1713 goto out_nomem;
1714
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001715 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001716 (struct sockaddr *)&vol->srcaddr,
1717 string, strlen(string))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001718 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1719 string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001720 goto cifs_parse_mount_err;
1721 }
1722 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001723 case Opt_iocharset:
1724 string = match_strdup(args);
1725 if (string == NULL)
1726 goto out_nomem;
1727
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001728 if (strnlen(string, 1024) >= 65) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001729 pr_warn("CIFS: iocharset name too long.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001730 goto cifs_parse_mount_err;
1731 }
1732
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001733 if (strncasecmp(string, "default", 7) != 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001734 vol->iocharset = kstrdup(string,
1735 GFP_KERNEL);
1736 if (!vol->iocharset) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001737 pr_warn("CIFS: no memory for charset\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001738 goto cifs_parse_mount_err;
1739 }
1740 }
1741 /* if iocharset not set then load_nls_default
1742 * is used by caller
1743 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001744 cifs_dbg(FYI, "iocharset set to %s\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001745 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001746 case Opt_netbiosname:
1747 string = match_strdup(args);
1748 if (string == NULL)
1749 goto out_nomem;
1750
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001751 memset(vol->source_rfc1001_name, 0x20,
1752 RFC1001_NAME_LEN);
1753 /*
1754 * FIXME: are there cases in which a comma can
1755 * be valid in workstation netbios name (and
1756 * need special handling)?
1757 */
1758 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1759 /* don't ucase netbiosname for user */
1760 if (string[i] == 0)
1761 break;
1762 vol->source_rfc1001_name[i] = string[i];
1763 }
1764 /* The string has 16th byte zero still from
1765 * set at top of the function
1766 */
1767 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001768 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001769 break;
1770 case Opt_servern:
1771 /* servernetbiosname specified override *SMBSERVER */
1772 string = match_strdup(args);
1773 if (string == NULL)
1774 goto out_nomem;
1775
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001776 /* last byte, type, is 0x20 for servr type */
1777 memset(vol->target_rfc1001_name, 0x20,
1778 RFC1001_NAME_LEN_WITH_NULL);
1779
1780 /* BB are there cases in which a comma can be
1781 valid in this workstation netbios name
1782 (and need special handling)? */
1783
1784 /* user or mount helper must uppercase the
1785 netbios name */
1786 for (i = 0; i < 15; i++) {
1787 if (string[i] == 0)
1788 break;
1789 vol->target_rfc1001_name[i] = string[i];
1790 }
1791 /* The string has 16th byte zero still from
1792 set at top of the function */
1793 if (i == RFC1001_NAME_LEN && string[i] != 0)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001794 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001795 break;
1796 case Opt_ver:
1797 string = match_strdup(args);
1798 if (string == NULL)
1799 goto out_nomem;
1800
Rasmus Villemoes87e747c2014-10-13 15:54:35 -07001801 if (strncasecmp(string, "1", 1) == 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001802 /* This is the default */
1803 break;
1804 }
1805 /* For all other value, error */
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001806 pr_warn("CIFS: Invalid version specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001807 goto cifs_parse_mount_err;
Jeff Layton23db65f2012-05-15 12:20:51 -04001808 case Opt_vers:
1809 string = match_strdup(args);
1810 if (string == NULL)
1811 goto out_nomem;
1812
1813 if (cifs_parse_smb_version(string, vol) != 0)
1814 goto cifs_parse_mount_err;
1815 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001816 case Opt_sec:
1817 string = match_strdup(args);
1818 if (string == NULL)
1819 goto out_nomem;
1820
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001821 if (cifs_parse_security_flavors(string, vol) != 0)
1822 goto cifs_parse_mount_err;
1823 break;
Jeff Layton15b6a472012-05-16 07:50:15 -04001824 case Opt_cache:
1825 string = match_strdup(args);
1826 if (string == NULL)
1827 goto out_nomem;
1828
1829 if (cifs_parse_cache_flavor(string, vol) != 0)
1830 goto cifs_parse_mount_err;
1831 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001832 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001833 /*
1834 * An option we don't recognize. Save it off for later
1835 * if we haven't already found one
1836 */
1837 if (!invalid)
1838 invalid = data;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001839 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001841 /* Free up any allocated string */
1842 kfree(string);
1843 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001845
Jeff Laytond8162552012-03-23 14:40:56 -04001846 if (!sloppy && invalid) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001847 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
Jeff Laytond8162552012-03-23 14:40:56 -04001848 goto cifs_parse_mount_err;
1849 }
1850
Jeff Layton8a8798a2012-01-17 16:09:15 -05001851#ifndef CONFIG_KEYS
1852 /* Muliuser mounts require CONFIG_KEYS support */
1853 if (vol->multiuser) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001854 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001855 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001856 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001857#endif
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001858 if (!vol->UNC) {
Jeff Layton37d4f992013-05-24 07:40:05 -04001859 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001860 goto cifs_parse_mount_err;
1861 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001862
Jeff Layton62a1a432012-12-10 06:10:45 -05001863 /* make sure UNC has a share name */
1864 if (!strchr(vol->UNC + 3, '\\')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001865 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
Jeff Layton62a1a432012-12-10 06:10:45 -05001866 goto cifs_parse_mount_err;
1867 }
1868
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001869 if (!got_ip) {
1870 /* No ip= option specified? Try to get it from UNC */
1871 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1872 strlen(&vol->UNC[2]))) {
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001873 pr_err("Unable to determine destination address.\n");
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001874 goto cifs_parse_mount_err;
1875 }
1876 }
1877
1878 /* set the port that we got earlier */
1879 cifs_set_port(dstaddr, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001881 if (uid_specified)
1882 vol->override_uid = override_uid;
1883 else if (override_uid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001884 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001885
1886 if (gid_specified)
1887 vol->override_gid = override_gid;
1888 else if (override_gid == 1)
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001889 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001890
Sean Finneyb9468452011-04-11 13:19:32 +00001891 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001893
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001894out_nomem:
Andy Shevchenko0b456f02014-08-27 16:49:44 +03001895 pr_warn("Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001896cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001897 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001898 kfree(mountdata_copy);
1899 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900}
1901
Ben Greear3eb9a882010-09-01 17:06:02 -07001902/** Returns true if srcaddr isn't specified and rhs isn't
1903 * specified, or if srcaddr is specified and
1904 * matches the IP address of the rhs argument.
1905 */
Jeff Layton45151482010-07-06 20:43:02 -04001906static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001907srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1908{
1909 switch (srcaddr->sa_family) {
1910 case AF_UNSPEC:
1911 return (rhs->sa_family == AF_UNSPEC);
1912 case AF_INET: {
1913 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1914 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1915 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1916 }
1917 case AF_INET6: {
1918 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
Nickolai Zeldoviche3e27752013-01-16 21:36:17 -05001919 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
Ben Greear3eb9a882010-09-01 17:06:02 -07001920 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1921 }
1922 default:
1923 WARN_ON(1);
1924 return false; /* don't expect to be here */
1925 }
1926}
1927
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001928/*
1929 * If no port is specified in addr structure, we try to match with 445 port
1930 * and if it fails - with 139 ports. It should be called only if address
1931 * families of server and addr are equal.
1932 */
1933static bool
1934match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1935{
Steve French6da97912011-03-13 18:55:55 +00001936 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001937
1938 switch (addr->sa_family) {
1939 case AF_INET:
1940 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1941 port = ((struct sockaddr_in *) addr)->sin_port;
1942 break;
1943 case AF_INET6:
1944 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1945 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1946 break;
1947 default:
1948 WARN_ON(1);
1949 return false;
1950 }
1951
1952 if (!port) {
1953 port = htons(CIFS_PORT);
1954 if (port == *sport)
1955 return true;
1956
1957 port = htons(RFC1001_PORT);
1958 }
1959
1960 return port == *sport;
1961}
Ben Greear3eb9a882010-09-01 17:06:02 -07001962
1963static bool
1964match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1965 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966{
Jeff Layton45151482010-07-06 20:43:02 -04001967 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001968 case AF_INET: {
1969 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1970 struct sockaddr_in *srv_addr4 =
1971 (struct sockaddr_in *)&server->dstaddr;
1972
1973 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001974 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001975 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001976 }
1977 case AF_INET6: {
1978 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1979 struct sockaddr_in6 *srv_addr6 =
1980 (struct sockaddr_in6 *)&server->dstaddr;
1981
Jeff Layton45151482010-07-06 20:43:02 -04001982 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001983 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001984 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001985 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001986 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001987 break;
1988 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001989 default:
1990 WARN_ON(1);
1991 return false; /* don't expect to be here */
1992 }
Jeff Layton45151482010-07-06 20:43:02 -04001993
Ben Greear3eb9a882010-09-01 17:06:02 -07001994 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1995 return false;
1996
Jeff Layton45151482010-07-06 20:43:02 -04001997 return true;
1998}
1999
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002000static bool
2001match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2002{
Jeff Layton3f618222013-06-12 19:52:14 -05002003 /*
2004 * The select_sectype function should either return the vol->sectype
2005 * that was specified, or "Unspecified" if that sectype was not
2006 * compatible with the given NEGOTIATE request.
2007 */
2008 if (select_sectype(server, vol->sectype) == Unspecified)
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002009 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002010
Jeff Layton3f618222013-06-12 19:52:14 -05002011 /*
2012 * Now check if signing mode is acceptable. No need to check
2013 * global_secflags at this point since if MUST_SIGN is set then
2014 * the server->sign had better be too.
2015 */
Jeff Layton38d77c52013-05-26 07:01:00 -04002016 if (vol->sign && !server->sign)
2017 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002018
2019 return true;
2020}
2021
Jeff Layton9fa114f2012-11-26 11:09:57 -05002022static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002023{
Jeff Layton9fa114f2012-11-26 11:09:57 -05002024 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2025
Jeff Laytona0b3df52013-05-24 07:40:59 -04002026 if (vol->nosharesock)
2027 return 0;
2028
Jeff Layton23db65f2012-05-15 12:20:51 -04002029 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2030 return 0;
2031
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002032 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2033 return 0;
2034
2035 if (!match_address(server, addr,
2036 (struct sockaddr *)&vol->srcaddr))
2037 return 0;
2038
2039 if (!match_port(server, addr))
2040 return 0;
2041
2042 if (!match_security(server, vol))
2043 return 0;
2044
2045 return 1;
2046}
2047
Jeff Layton45151482010-07-06 20:43:02 -04002048static struct TCP_Server_Info *
Jeff Layton9fa114f2012-11-26 11:09:57 -05002049cifs_find_tcp_session(struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002050{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002051 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302053 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002054 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Jeff Layton9fa114f2012-11-26 11:09:57 -05002055 if (!match_server(server, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002056 continue;
2057
Jeff Laytone7ddee92008-11-14 13:44:38 -05002058 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302059 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesf96637b2013-05-04 22:12:25 -05002060 cifs_dbg(FYI, "Existing tcp session with server found\n");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002061 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302063 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 return NULL;
2065}
2066
Jeff Layton14fbf502008-11-14 13:53:46 -05002067static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002068cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069{
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002070 struct task_struct *task;
2071
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302072 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002073 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302074 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002075 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 }
Steve Frenchdea570e02008-05-06 22:05:51 +00002077
Rob Landleyf1d0c992011-01-22 15:44:05 -06002078 put_net(cifs_net_ns(server));
2079
Jeff Laytone7ddee92008-11-14 13:44:38 -05002080 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302081 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002082
Jeff Laytonc74093b2011-01-11 07:24:23 -05002083 cancel_delayed_work_sync(&server->echo);
2084
Jeff Laytone7ddee92008-11-14 13:44:38 -05002085 spin_lock(&GlobalMid_Lock);
2086 server->tcpStatus = CifsExiting;
2087 spin_unlock(&GlobalMid_Lock);
2088
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002089 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302090 cifs_fscache_release_client_cookie(server);
2091
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002092 kfree(server->session_key.response);
2093 server->session_key.response = NULL;
2094 server->session_key.len = 0;
Steve Frencha5c3e1c2014-09-16 04:16:19 -05002095
2096 task = xchg(&server->tsk, NULL);
2097 if (task)
2098 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099}
2100
Jeff Layton63c038c2008-12-01 18:41:46 -05002101static struct TCP_Server_Info *
2102cifs_get_tcp_session(struct smb_vol *volume_info)
2103{
2104 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Layton63c038c2008-12-01 18:41:46 -05002105 int rc;
2106
Joe Perchesf96637b2013-05-04 22:12:25 -05002107 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
Jeff Layton63c038c2008-12-01 18:41:46 -05002108
2109 /* see if we already have a matching tcp_ses */
Jeff Layton9fa114f2012-11-26 11:09:57 -05002110 tcp_ses = cifs_find_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002111 if (tcp_ses)
2112 return tcp_ses;
2113
2114 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2115 if (!tcp_ses) {
2116 rc = -ENOMEM;
2117 goto out_err;
2118 }
2119
Jeff Layton23db65f2012-05-15 12:20:51 -04002120 tcp_ses->ops = volume_info->ops;
2121 tcp_ses->vals = volume_info->vals;
Rob Landleyf1d0c992011-01-22 15:44:05 -06002122 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002123 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2124 if (IS_ERR(tcp_ses->hostname)) {
2125 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002126 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002127 }
2128
2129 tcp_ses->noblocksnd = volume_info->noblocksnd;
2130 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002131 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002132 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002133 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002134 init_waitqueue_head(&tcp_ses->response_q);
2135 init_waitqueue_head(&tcp_ses->request_q);
2136 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2137 mutex_init(&tcp_ses->srv_mutex);
2138 memcpy(tcp_ses->workstation_RFC1001_name,
2139 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2140 memcpy(tcp_ses->server_RFC1001_name,
2141 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002142 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002143 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002144 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002145 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002146 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2147 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002148 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton9fa114f2012-11-26 11:09:57 -05002149 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2150 sizeof(tcp_ses->srcaddr));
2151 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2152 sizeof(tcp_ses->dstaddr));
Sachin Prabhu39552ea2014-05-13 00:48:12 +01002153#ifdef CONFIG_CIFS_SMB2
2154 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2155#endif
Jeff Layton63c038c2008-12-01 18:41:46 -05002156 /*
2157 * at this point we are the only ones with the pointer
2158 * to the struct since the kernel thread not created yet
2159 * no need to spinlock this init of tcpStatus or srv_count
2160 */
2161 tcp_ses->tcpStatus = CifsNew;
2162 ++tcp_ses->srv_count;
2163
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002164 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002165 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002166 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002167 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002168 }
2169
2170 /*
2171 * since we're in a cifs function already, we know that
2172 * this will succeed. No need for try_module_get().
2173 */
2174 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002175 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002176 tcp_ses, "cifsd");
2177 if (IS_ERR(tcp_ses->tsk)) {
2178 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesf96637b2013-05-04 22:12:25 -05002179 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002180 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002181 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002182 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002183 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002184
2185 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302186 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002187 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302188 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002189
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302190 cifs_fscache_get_client_cookie(tcp_ses);
2191
Jeff Laytonc74093b2011-01-11 07:24:23 -05002192 /* queue echo request delayed work */
Jeff Laytonda472fc2012-03-23 14:40:53 -04002193 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002194
Jeff Layton63c038c2008-12-01 18:41:46 -05002195 return tcp_ses;
2196
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002197out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002198 cifs_crypto_shash_release(tcp_ses);
2199
Rob Landleyf1d0c992011-01-22 15:44:05 -06002200 put_net(cifs_net_ns(tcp_ses));
2201
Jeff Layton63c038c2008-12-01 18:41:46 -05002202out_err:
2203 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00002204 if (!IS_ERR(tcp_ses->hostname))
2205 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002206 if (tcp_ses->ssocket)
2207 sock_release(tcp_ses->ssocket);
2208 kfree(tcp_ses);
2209 }
2210 return ERR_PTR(rc);
2211}
2212
Steve French96daf2b2011-05-27 04:34:02 +00002213static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002214{
Jeff Layton3f618222013-06-12 19:52:14 -05002215 if (vol->sectype != Unspecified &&
2216 vol->sectype != ses->sectype)
2217 return 0;
2218
2219 switch (ses->sectype) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002220 case Kerberos:
Eric W. Biederman64ed39d2013-02-06 02:30:39 -08002221 if (!uid_eq(vol->cred_uid, ses->cred_uid))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002222 return 0;
2223 break;
2224 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002225 /* NULL username means anonymous session */
2226 if (ses->user_name == NULL) {
2227 if (!vol->nullauth)
2228 return 0;
2229 break;
2230 }
2231
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002232 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002233 if (strncmp(ses->user_name,
2234 vol->username ? vol->username : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002235 CIFS_MAX_USERNAME_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002236 return 0;
Jeff Layton08b37d52014-05-23 06:53:10 -04002237 if ((vol->username && strlen(vol->username) != 0) &&
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002238 ses->password != NULL &&
2239 strncmp(ses->password,
2240 vol->password ? vol->password : "",
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002241 CIFS_MAX_PASSWORD_LEN))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002242 return 0;
2243 }
2244 return 1;
2245}
2246
Steve French96daf2b2011-05-27 04:34:02 +00002247static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002248cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249{
Steve French96daf2b2011-05-27 04:34:02 +00002250 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302252 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002253 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002254 if (ses->status == CifsExiting)
2255 continue;
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002256 if (!match_session(ses, vol))
2257 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002258 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302259 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002260 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302262 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 return NULL;
2264}
2265
Jeff Layton14fbf502008-11-14 13:53:46 -05002266static void
Steve French96daf2b2011-05-27 04:34:02 +00002267cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002268{
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002269 unsigned int rc, xid;
Jeff Layton14fbf502008-11-14 13:53:46 -05002270 struct TCP_Server_Info *server = ses->server;
2271
Joe Perchesf96637b2013-05-04 22:12:25 -05002272 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002273
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302274 spin_lock(&cifs_tcp_ses_lock);
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002275 if (ses->status == CifsExiting) {
2276 spin_unlock(&cifs_tcp_ses_lock);
2277 return;
2278 }
Jeff Layton14fbf502008-11-14 13:53:46 -05002279 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302280 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002281 return;
2282 }
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002283 if (ses->status == CifsGood)
2284 ses->status = CifsExiting;
2285 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002286
Shirish Pargaonkar7f485582013-10-12 10:06:03 -05002287 if (ses->status == CifsExiting && server->ops->logoff) {
2288 xid = get_xid();
2289 rc = server->ops->logoff(xid, ses);
2290 if (rc)
2291 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2292 __func__, rc);
2293 _free_xid(xid);
2294 }
2295
2296 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002297 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302298 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002299
Jeff Layton14fbf502008-11-14 13:53:46 -05002300 sesInfoFree(ses);
2301 cifs_put_tcp_session(server);
2302}
2303
Jeff Layton8a8798a2012-01-17 16:09:15 -05002304#ifdef CONFIG_KEYS
2305
Chen Gang057d6332013-07-19 09:01:36 +08002306/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2307#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
Jeff Layton8a8798a2012-01-17 16:09:15 -05002308
2309/* Populate username and pw fields from keyring if possible */
2310static int
2311cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2312{
2313 int rc = 0;
2314 char *desc, *delim, *payload;
2315 ssize_t len;
2316 struct key *key;
2317 struct TCP_Server_Info *server = ses->server;
2318 struct sockaddr_in *sa;
2319 struct sockaddr_in6 *sa6;
2320 struct user_key_payload *upayload;
2321
2322 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2323 if (!desc)
2324 return -ENOMEM;
2325
2326 /* try to find an address key first */
2327 switch (server->dstaddr.ss_family) {
2328 case AF_INET:
2329 sa = (struct sockaddr_in *)&server->dstaddr;
2330 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2331 break;
2332 case AF_INET6:
2333 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2334 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2335 break;
2336 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05002337 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2338 server->dstaddr.ss_family);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002339 rc = -EINVAL;
2340 goto out_err;
2341 }
2342
Joe Perchesf96637b2013-05-04 22:12:25 -05002343 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002344 key = request_key(&key_type_logon, desc, "");
2345 if (IS_ERR(key)) {
2346 if (!ses->domainName) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002347 cifs_dbg(FYI, "domainName is NULL\n");
Jeff Layton8a8798a2012-01-17 16:09:15 -05002348 rc = PTR_ERR(key);
2349 goto out_err;
2350 }
2351
2352 /* didn't work, try to find a domain key */
2353 sprintf(desc, "cifs:d:%s", ses->domainName);
Joe Perchesf96637b2013-05-04 22:12:25 -05002354 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002355 key = request_key(&key_type_logon, desc, "");
2356 if (IS_ERR(key)) {
2357 rc = PTR_ERR(key);
2358 goto out_err;
2359 }
2360 }
2361
2362 down_read(&key->sem);
2363 upayload = key->payload.data;
2364 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002365 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002366 goto out_key_put;
2367 }
2368
2369 /* find first : in payload */
2370 payload = (char *)upayload->data;
2371 delim = strnchr(payload, upayload->datalen, ':');
Joe Perchesf96637b2013-05-04 22:12:25 -05002372 cifs_dbg(FYI, "payload=%s\n", payload);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002373 if (!delim) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002374 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2375 upayload->datalen);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002376 rc = -EINVAL;
2377 goto out_key_put;
2378 }
2379
2380 len = delim - payload;
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002381 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002382 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2383 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002384 rc = -EINVAL;
2385 goto out_key_put;
2386 }
2387
2388 vol->username = kstrndup(payload, len, GFP_KERNEL);
2389 if (!vol->username) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002390 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2391 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002392 rc = -ENOMEM;
2393 goto out_key_put;
2394 }
Joe Perchesf96637b2013-05-04 22:12:25 -05002395 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002396
2397 len = key->datalen - (len + 1);
Scott Lovenberg8c3a2b42013-08-09 08:47:17 -04002398 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002399 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002400 rc = -EINVAL;
2401 kfree(vol->username);
2402 vol->username = NULL;
2403 goto out_key_put;
2404 }
2405
2406 ++delim;
2407 vol->password = kstrndup(delim, len, GFP_KERNEL);
2408 if (!vol->password) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002409 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2410 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002411 rc = -ENOMEM;
2412 kfree(vol->username);
2413 vol->username = NULL;
2414 goto out_key_put;
2415 }
2416
2417out_key_put:
2418 up_read(&key->sem);
2419 key_put(key);
2420out_err:
2421 kfree(desc);
Joe Perchesf96637b2013-05-04 22:12:25 -05002422 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002423 return rc;
2424}
2425#else /* ! CONFIG_KEYS */
2426static inline int
2427cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2428 struct cifs_ses *ses __attribute__((unused)))
2429{
2430 return -ENOSYS;
2431}
2432#endif /* CONFIG_KEYS */
2433
Steve French96daf2b2011-05-27 04:34:02 +00002434static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002435cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2436{
Pavel Shilovsky286170a2012-05-25 10:43:58 +04002437 int rc = -ENOMEM;
2438 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002439 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002440 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2441 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002442
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002443 xid = get_xid();
Jeff Layton36988c72010-04-24 07:57:43 -04002444
Jeff Layton4ff67b72010-07-06 20:43:02 -04002445 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002446 if (ses) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002447 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2448 ses->status);
Jeff Layton36988c72010-04-24 07:57:43 -04002449
Jeff Layton36988c72010-04-24 07:57:43 -04002450 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002451 rc = cifs_negotiate_protocol(xid, ses);
2452 if (rc) {
2453 mutex_unlock(&ses->session_mutex);
2454 /* problem -- put our ses reference */
2455 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002456 free_xid(xid);
Jeff Layton198b5682010-04-24 07:57:48 -04002457 return ERR_PTR(rc);
2458 }
Jeff Layton36988c72010-04-24 07:57:43 -04002459 if (ses->need_reconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002460 cifs_dbg(FYI, "Session needs reconnect\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002461 rc = cifs_setup_session(xid, ses,
2462 volume_info->local_nls);
2463 if (rc) {
2464 mutex_unlock(&ses->session_mutex);
2465 /* problem -- put our reference */
2466 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002467 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002468 return ERR_PTR(rc);
2469 }
2470 }
2471 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002472
2473 /* existing SMB ses has a server reference already */
2474 cifs_put_tcp_session(server);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002475 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002476 return ses;
2477 }
2478
Joe Perchesf96637b2013-05-04 22:12:25 -05002479 cifs_dbg(FYI, "Existing smb sess not found\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002480 ses = sesInfoAlloc();
2481 if (ses == NULL)
2482 goto get_ses_fail;
2483
2484 /* new SMB session uses our server ref */
2485 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002486 if (server->dstaddr.ss_family == AF_INET6)
2487 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002488 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002489 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002490
Steve French8727c8a2011-02-25 01:11:56 -06002491 if (volume_info->username) {
2492 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2493 if (!ses->user_name)
2494 goto get_ses_fail;
2495 }
Jeff Layton36988c72010-04-24 07:57:43 -04002496
2497 /* volume_info->password freed at unmount */
2498 if (volume_info->password) {
2499 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2500 if (!ses->password)
2501 goto get_ses_fail;
2502 }
2503 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002504 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2505 if (!ses->domainName)
2506 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002507 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002508 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002509 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002510
Jeff Layton28e11bd2013-05-26 07:01:00 -04002511 ses->sectype = volume_info->sectype;
2512 ses->sign = volume_info->sign;
Jeff Layton36988c72010-04-24 07:57:43 -04002513
2514 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002515 rc = cifs_negotiate_protocol(xid, ses);
2516 if (!rc)
2517 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002518 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002519 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002520 goto get_ses_fail;
2521
2522 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302523 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002524 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302525 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002526
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002527 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002528 return ses;
2529
2530get_ses_fail:
2531 sesInfoFree(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002532 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002533 return ERR_PTR(rc);
2534}
2535
Steve French96daf2b2011-05-27 04:34:02 +00002536static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002537{
2538 if (tcon->tidStatus == CifsExiting)
2539 return 0;
2540 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2541 return 0;
2542 return 1;
2543}
2544
Steve French96daf2b2011-05-27 04:34:02 +00002545static struct cifs_tcon *
2546cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547{
2548 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002549 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302551 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002552 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002553 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002554 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002555 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002556 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302557 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 return tcon;
2559 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302560 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 return NULL;
2562}
2563
Jeff Laytonf1987b42008-11-15 11:12:47 -05002564static void
Steve French96daf2b2011-05-27 04:34:02 +00002565cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002566{
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002567 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002568 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002569
Joe Perchesf96637b2013-05-04 22:12:25 -05002570 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302571 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002572 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302573 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002574 return;
2575 }
2576
2577 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302578 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002579
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002580 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002581 if (ses->server->ops->tree_disconnect)
2582 ses->server->ops->tree_disconnect(xid, tcon);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002583 _free_xid(xid);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002584
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302585 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002586 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002587 cifs_put_smb_ses(ses);
2588}
2589
Steve French96daf2b2011-05-27 04:34:02 +00002590static struct cifs_tcon *
2591cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002592{
2593 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002594 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002595
2596 tcon = cifs_find_tcon(ses, volume_info->UNC);
2597 if (tcon) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002598 cifs_dbg(FYI, "Found match on UNC path\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002599 /* existing tcon already has a reference */
2600 cifs_put_smb_ses(ses);
2601 if (tcon->seal != volume_info->seal)
Joe Perchesf96637b2013-05-04 22:12:25 -05002602 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002603 return tcon;
2604 }
2605
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002606 if (!ses->server->ops->tree_connect) {
2607 rc = -ENOSYS;
2608 goto out_fail;
2609 }
2610
Jeff Laytond00c28d2010-04-24 07:57:44 -04002611 tcon = tconInfoAlloc();
2612 if (tcon == NULL) {
2613 rc = -ENOMEM;
2614 goto out_fail;
2615 }
2616
2617 tcon->ses = ses;
2618 if (volume_info->password) {
2619 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2620 if (!tcon->password) {
2621 rc = -ENOMEM;
2622 goto out_fail;
2623 }
2624 }
2625
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002626 /*
2627 * BB Do we need to wrap session_mutex around this TCon call and Unix
2628 * SetFS as we do on SessSetup and reconnect?
2629 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002630 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002631 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2632 volume_info->local_nls);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002633 free_xid(xid);
Joe Perchesf96637b2013-05-04 22:12:25 -05002634 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002635 if (rc)
2636 goto out_fail;
2637
2638 if (volume_info->nodfs) {
2639 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002640 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002641 }
2642 tcon->seal = volume_info->seal;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002643 /*
2644 * We can have only one retry value for a connection to a share so for
2645 * resources mounted more than once to the same server share the last
2646 * value passed in for the retry flag is used.
2647 */
Jeff Laytond00c28d2010-04-24 07:57:44 -04002648 tcon->retry = volume_info->retry;
2649 tcon->nocase = volume_info->nocase;
2650 tcon->local_lease = volume_info->local_lease;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07002651 INIT_LIST_HEAD(&tcon->pending_opens);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002652
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302653 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002654 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302655 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002656
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302657 cifs_fscache_get_super_cookie(tcon);
2658
Jeff Laytond00c28d2010-04-24 07:57:44 -04002659 return tcon;
2660
2661out_fail:
2662 tconInfoFree(tcon);
2663 return ERR_PTR(rc);
2664}
2665
Jeff Layton9d002df2010-10-06 19:51:11 -04002666void
2667cifs_put_tlink(struct tcon_link *tlink)
2668{
2669 if (!tlink || IS_ERR(tlink))
2670 return;
2671
2672 if (!atomic_dec_and_test(&tlink->tl_count) ||
2673 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2674 tlink->tl_time = jiffies;
2675 return;
2676 }
2677
2678 if (!IS_ERR(tlink_tcon(tlink)))
2679 cifs_put_tcon(tlink_tcon(tlink));
2680 kfree(tlink);
2681 return;
2682}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002683
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002684static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002685cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2686{
2687 return cifs_sb->master_tlink;
2688}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002689
2690static int
2691compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2692{
2693 struct cifs_sb_info *old = CIFS_SB(sb);
2694 struct cifs_sb_info *new = mnt_data->cifs_sb;
2695
2696 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2697 return 0;
2698
2699 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2700 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2701 return 0;
2702
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002703 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002704 * We want to share sb only if we don't specify an r/wsize or
2705 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002706 */
2707 if (new->wsize && new->wsize < old->wsize)
2708 return 0;
2709
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002710 if (new->rsize && new->rsize < old->rsize)
2711 return 0;
2712
Eric W. Biederman1f682332013-02-06 01:20:20 -08002713 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002714 return 0;
2715
2716 if (old->mnt_file_mode != new->mnt_file_mode ||
2717 old->mnt_dir_mode != new->mnt_dir_mode)
2718 return 0;
2719
2720 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2721 return 0;
2722
2723 if (old->actimeo != new->actimeo)
2724 return 0;
2725
2726 return 1;
2727}
2728
2729int
2730cifs_match_super(struct super_block *sb, void *data)
2731{
2732 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2733 struct smb_vol *volume_info;
2734 struct cifs_sb_info *cifs_sb;
2735 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002736 struct cifs_ses *ses;
2737 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002738 struct tcon_link *tlink;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002739 int rc = 0;
2740
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002741 spin_lock(&cifs_tcp_ses_lock);
2742 cifs_sb = CIFS_SB(sb);
2743 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2744 if (IS_ERR(tlink)) {
2745 spin_unlock(&cifs_tcp_ses_lock);
2746 return rc;
2747 }
2748 tcon = tlink_tcon(tlink);
2749 ses = tcon->ses;
2750 tcp_srv = ses->server;
2751
2752 volume_info = mnt_data->vol;
2753
Jeff Layton9fa114f2012-11-26 11:09:57 -05002754 if (!match_server(tcp_srv, volume_info) ||
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002755 !match_session(ses, volume_info) ||
2756 !match_tcon(tcon, volume_info->UNC)) {
2757 rc = 0;
2758 goto out;
2759 }
2760
2761 rc = compare_mount_options(sb, mnt_data);
2762out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002763 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002764 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002765 return rc;
2766}
2767
Linus Torvalds1da177e2005-04-16 15:20:36 -07002768int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002769get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002770 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2771 struct dfs_info3_param **referrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772{
2773 char *temp_unc;
2774 int rc = 0;
2775
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002776 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002777 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002779 *num_referrals = 0;
2780 *referrals = NULL;
2781
2782 if (ses->ipc_tid == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783 temp_unc = kmalloc(2 /* for slashes */ +
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002784 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2785 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002786 if (temp_unc == NULL)
2787 return -ENOMEM;
2788 temp_unc[0] = '\\';
2789 temp_unc[1] = '\\';
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002790 strcpy(temp_unc + 2, ses->serverName);
2791 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2792 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2793 nls_codepage);
Joe Perchesf96637b2013-05-04 22:12:25 -05002794 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795 kfree(temp_unc);
2796 }
2797 if (rc == 0)
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002798 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2799 referrals, num_referrals,
2800 nls_codepage, remap);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002801 /*
2802 * BB - map targetUNCs to dfs_info3 structures, here or in
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002803 * ses->server->ops->get_dfs_refer.
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002804 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805
2806 return rc;
2807}
2808
Jeff Layton09e50d52008-07-23 10:11:19 -04002809#ifdef CONFIG_DEBUG_LOCK_ALLOC
2810static struct lock_class_key cifs_key[2];
2811static struct lock_class_key cifs_slock_key[2];
2812
2813static inline void
2814cifs_reclassify_socket4(struct socket *sock)
2815{
2816 struct sock *sk = sock->sk;
2817 BUG_ON(sock_owned_by_user(sk));
2818 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2819 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2820}
2821
2822static inline void
2823cifs_reclassify_socket6(struct socket *sock)
2824{
2825 struct sock *sk = sock->sk;
2826 BUG_ON(sock_owned_by_user(sk));
2827 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2828 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2829}
2830#else
2831static inline void
2832cifs_reclassify_socket4(struct socket *sock)
2833{
2834}
2835
2836static inline void
2837cifs_reclassify_socket6(struct socket *sock)
2838{
2839}
2840#endif
2841
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002843static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844{
Steve French50c2f752007-07-13 00:33:32 +00002845 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
Steve French50c2f752007-07-13 00:33:32 +00002847 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 /* mask a nibble at a time and encode */
2849 target[j] = 'A' + (0x0F & (source[i] >> 4));
2850 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002851 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 }
2853
2854}
2855
Ben Greear3eb9a882010-09-01 17:06:02 -07002856static int
2857bind_socket(struct TCP_Server_Info *server)
2858{
2859 int rc = 0;
2860 if (server->srcaddr.ss_family != AF_UNSPEC) {
2861 /* Bind to the specified local IP address */
2862 struct socket *socket = server->ssocket;
2863 rc = socket->ops->bind(socket,
2864 (struct sockaddr *) &server->srcaddr,
2865 sizeof(server->srcaddr));
2866 if (rc < 0) {
2867 struct sockaddr_in *saddr4;
2868 struct sockaddr_in6 *saddr6;
2869 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2870 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2871 if (saddr6->sin6_family == AF_INET6)
Joe Perchesf96637b2013-05-04 22:12:25 -05002872 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2873 &saddr6->sin6_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002874 else
Joe Perchesf96637b2013-05-04 22:12:25 -05002875 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2876 &saddr4->sin_addr.s_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002877 }
2878 }
2879 return rc;
2880}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
2882static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002883ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884{
2885 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002886 /*
2887 * some servers require RFC1001 sessinit before sending
2888 * negprot - BB check reconnection in case where second
2889 * sessinit is sent but no second negprot
2890 */
2891 struct rfc1002_session_packet *ses_init_buf;
2892 struct smb_hdr *smb_buf;
2893 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2894 GFP_KERNEL);
2895 if (ses_init_buf) {
2896 ses_init_buf->trailer.session_req.called_len = 32;
2897
2898 if (server->server_RFC1001_name &&
2899 server->server_RFC1001_name[0] != 0)
2900 rfc1002mangle(ses_init_buf->trailer.
2901 session_req.called_name,
2902 server->server_RFC1001_name,
2903 RFC1001_NAME_LEN_WITH_NULL);
2904 else
2905 rfc1002mangle(ses_init_buf->trailer.
2906 session_req.called_name,
2907 DEFAULT_CIFS_CALLED_NAME,
2908 RFC1001_NAME_LEN_WITH_NULL);
2909
2910 ses_init_buf->trailer.session_req.calling_len = 32;
2911
2912 /*
2913 * calling name ends in null (byte 16) from old smb
2914 * convention.
2915 */
2916 if (server->workstation_RFC1001_name &&
2917 server->workstation_RFC1001_name[0] != 0)
2918 rfc1002mangle(ses_init_buf->trailer.
2919 session_req.calling_name,
2920 server->workstation_RFC1001_name,
2921 RFC1001_NAME_LEN_WITH_NULL);
2922 else
2923 rfc1002mangle(ses_init_buf->trailer.
2924 session_req.calling_name,
2925 "LINUX_CIFS_CLNT",
2926 RFC1001_NAME_LEN_WITH_NULL);
2927
2928 ses_init_buf->trailer.session_req.scope1 = 0;
2929 ses_init_buf->trailer.session_req.scope2 = 0;
2930 smb_buf = (struct smb_hdr *)ses_init_buf;
2931
2932 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002933 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002934 rc = smb_send(server, smb_buf, 0x44);
2935 kfree(ses_init_buf);
2936 /*
2937 * RFC1001 layer in at least one server
2938 * requires very short break before negprot
2939 * presumably because not expecting negprot
2940 * to follow so fast. This is a simple
2941 * solution that works without
2942 * complicating the code and causes no
2943 * significant slowing down on mount
2944 * for everyone else
2945 */
2946 usleep_range(1000, 2000);
2947 }
2948 /*
2949 * else the negprot may still work without this
2950 * even though malloc failed
2951 */
2952
2953 return rc;
2954}
2955
2956static int
2957generic_ip_connect(struct TCP_Server_Info *server)
2958{
2959 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002960 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002961 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002962 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002963 struct sockaddr *saddr;
2964
2965 saddr = (struct sockaddr *) &server->dstaddr;
2966
2967 if (server->dstaddr.ss_family == AF_INET6) {
2968 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2969 slen = sizeof(struct sockaddr_in6);
2970 sfamily = AF_INET6;
2971 } else {
2972 sport = ((struct sockaddr_in *) saddr)->sin_port;
2973 slen = sizeof(struct sockaddr_in);
2974 sfamily = AF_INET;
2975 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002976
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002977 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002978 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2979 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002981 cifs_dbg(VFS, "Error %d creating socket\n", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002982 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002985
2986 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesf96637b2013-05-04 22:12:25 -05002987 cifs_dbg(FYI, "Socket created\n");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002988 server->ssocket = socket;
2989 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002990 if (sfamily == AF_INET6)
2991 cifs_reclassify_socket6(socket);
2992 else
2993 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002994 }
2995
Ben Greear3eb9a882010-09-01 17:06:02 -07002996 rc = bind_socket(server);
2997 if (rc < 0)
2998 return rc;
2999
Jeff Laytond5c56052008-12-01 18:42:33 -05003000 /*
3001 * Eventually check for other socket options to change from
3002 * the default. sock_setsockopt not used because it expects
3003 * user space buffer
3004 */
3005 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00003006 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00003007
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003008 /* make the bufsizes depend on wsize/rsize and max requests */
3009 if (server->noautotune) {
3010 if (socket->sk->sk_sndbuf < (200 * 1024))
3011 socket->sk->sk_sndbuf = 200 * 1024;
3012 if (socket->sk->sk_rcvbuf < (140 * 1024))
3013 socket->sk->sk_rcvbuf = 140 * 1024;
3014 }
3015
Steve French6a5fa2362010-01-01 01:28:43 +00003016 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003017 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00003018 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3019 (char *)&val, sizeof(val));
3020 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003021 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3022 rc);
Steve French6a5fa2362010-01-01 01:28:43 +00003023 }
3024
Joe Perchesf96637b2013-05-04 22:12:25 -05003025 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003026 socket->sk->sk_sndbuf,
3027 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3028
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003029 rc = socket->ops->connect(socket, saddr, slen, 0);
3030 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003031 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003032 sock_release(socket);
3033 server->ssocket = NULL;
3034 return rc;
3035 }
3036
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003037 if (sport == htons(RFC1001_PORT))
3038 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003039
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 return rc;
3041}
3042
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003043static int
3044ip_connect(struct TCP_Server_Info *server)
3045{
Steve French6da97912011-03-13 18:55:55 +00003046 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003047 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3048 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3049
3050 if (server->dstaddr.ss_family == AF_INET6)
3051 sport = &addr6->sin6_port;
3052 else
3053 sport = &addr->sin_port;
3054
3055 if (*sport == 0) {
3056 int rc;
3057
3058 /* try with 445 port at first */
3059 *sport = htons(CIFS_PORT);
3060
3061 rc = generic_ip_connect(server);
3062 if (rc >= 0)
3063 return rc;
3064
3065 /* if it failed, try with 139 port */
3066 *sport = htons(RFC1001_PORT);
3067 }
3068
3069 return generic_ip_connect(server);
3070}
3071
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003072void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003073 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003074{
3075 /* if we are reconnecting then should we check to see if
3076 * any requested capabilities changed locally e.g. via
3077 * remount but we can not do much about it here
3078 * if they have (even if we could detect it by the following)
3079 * Perhaps we could add a backpointer to array of sb from tcon
3080 * or if we change to make all sb to same share the same
3081 * sb as NFS - then we only have one backpointer to sb.
3082 * What if we wanted to mount the server share twice once with
3083 * and once without posixacls or posix paths? */
3084 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003085
Steve Frenchc18c8422007-07-18 23:21:09 +00003086 if (vol_info && vol_info->no_linux_ext) {
3087 tcon->fsUnixInfo.Capability = 0;
3088 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesf96637b2013-05-04 22:12:25 -05003089 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003090 return;
3091 } else if (vol_info)
3092 tcon->unix_ext = 1; /* Unix Extensions supported */
3093
3094 if (tcon->unix_ext == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003095 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003096 return;
3097 }
Steve French50c2f752007-07-13 00:33:32 +00003098
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003099 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003100 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Joe Perchesf96637b2013-05-04 22:12:25 -05003101 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
Steve French8af18972007-02-14 04:42:51 +00003102 /* check for reconnect case in which we do not
3103 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003104 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003105 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003106 originally at mount time */
3107 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3108 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003109 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3110 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003111 cifs_dbg(VFS, "POSIXPATH support change\n");
Steve French8af18972007-02-14 04:42:51 +00003112 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003113 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003114 cifs_dbg(VFS, "possible reconnect error\n");
3115 cifs_dbg(VFS, "server disabled POSIX path support\n");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003116 }
Steve French8af18972007-02-14 04:42:51 +00003117 }
Steve French50c2f752007-07-13 00:33:32 +00003118
Steve French6848b732011-05-26 18:38:54 +00003119 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003120 cifs_dbg(VFS, "per-share encryption not supported yet\n");
Steve French6848b732011-05-26 18:38:54 +00003121
Steve French8af18972007-02-14 04:42:51 +00003122 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003123 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003124 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003125 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003126 cifs_dbg(FYI, "negotiated posix acl support\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003127 if (cifs_sb)
3128 cifs_sb->mnt_cifs_flags |=
3129 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003130 }
3131
Steve French75865f8c2007-06-24 18:30:48 +00003132 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003133 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003134 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003135 cifs_dbg(FYI, "negotiate posix pathnames\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003136 if (cifs_sb)
3137 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003138 CIFS_MOUNT_POSIX_PATHS;
3139 }
Steve French50c2f752007-07-13 00:33:32 +00003140
Joe Perchesf96637b2013-05-04 22:12:25 -05003141 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003142#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003143 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003144 cifs_dbg(FYI, "FCNTL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003145 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003146 cifs_dbg(FYI, "EXTATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003147 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003148 cifs_dbg(FYI, "POSIX path cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003149 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003150 cifs_dbg(FYI, "XATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003151 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003152 cifs_dbg(FYI, "POSIX ACL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003153 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003154 cifs_dbg(FYI, "very large read cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003155 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003156 cifs_dbg(FYI, "very large write cap\n");
Steve French6848b732011-05-26 18:38:54 +00003157 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003158 cifs_dbg(FYI, "transport encryption cap\n");
Steve French6848b732011-05-26 18:38:54 +00003159 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003160 cifs_dbg(FYI, "mandatory transport encryption cap\n");
Steve French8af18972007-02-14 04:42:51 +00003161#endif /* CIFS_DEBUG2 */
3162 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003163 if (vol_info == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003164 cifs_dbg(FYI, "resetting capabilities failed\n");
Steve French442aa312007-09-24 20:25:46 +00003165 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05003166 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 +00003167
Steve French8af18972007-02-14 04:42:51 +00003168 }
3169 }
3170}
3171
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003172void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3173 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003174{
Jeff Layton2de970f2010-10-06 19:51:12 -04003175 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3176
Al Viro2ced6f62011-06-17 09:20:04 -04003177 spin_lock_init(&cifs_sb->tlink_tree_lock);
3178 cifs_sb->tlink_tree = RB_ROOT;
3179
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003180 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003181 * Temporarily set r/wsize for matching superblock. If we end up using
3182 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003183 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003184 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003185 cifs_sb->wsize = pvolume_info->wsize;
3186
Steve French3b795212008-11-13 19:45:32 +00003187 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3188 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3189 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3190 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -05003191 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3192 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003193
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303194 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003195 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303196
Steve French3b795212008-11-13 19:45:32 +00003197 if (pvolume_info->noperm)
3198 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3199 if (pvolume_info->setuids)
3200 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3201 if (pvolume_info->server_ino)
3202 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3203 if (pvolume_info->remap)
Steve French2baa2682014-09-27 02:19:01 -05003204 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3205 if (pvolume_info->sfu_remap)
Steve French3b795212008-11-13 19:45:32 +00003206 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3207 if (pvolume_info->no_xattr)
3208 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3209 if (pvolume_info->sfu_emul)
3210 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3211 if (pvolume_info->nobrl)
3212 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003213 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003214 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003215 if (pvolume_info->mand_lock)
3216 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003217 if (pvolume_info->rwpidforward)
3218 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003219 if (pvolume_info->cifs_acl)
3220 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003221 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003222 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003223 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3224 }
3225 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003226 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003227 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3228 }
Steve French3b795212008-11-13 19:45:32 +00003229 if (pvolume_info->override_uid)
3230 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3231 if (pvolume_info->override_gid)
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3233 if (pvolume_info->dynperm)
3234 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303235 if (pvolume_info->fsc)
3236 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003237 if (pvolume_info->multiuser)
3238 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3239 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003240 if (pvolume_info->strict_io)
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003242 if (pvolume_info->direct_io) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003243 cifs_dbg(FYI, "mounting share using direct i/o\n");
Steve French3b795212008-11-13 19:45:32 +00003244 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3245 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003246 if (pvolume_info->mfsymlinks) {
3247 if (pvolume_info->sfu_emul) {
Steve Frenchdb8b6312014-09-22 05:13:55 -05003248 /*
3249 * Our SFU ("Services for Unix" emulation does not allow
3250 * creating symlinks but does allow reading existing SFU
3251 * symlinks (it does allow both creating and reading SFU
3252 * style mknod and FIFOs though). When "mfsymlinks" and
3253 * "sfu" are both enabled at the same time, it allows
3254 * reading both types of symlinks, but will only create
3255 * them with mfsymlinks format. This allows better
3256 * Apple compatibility (probably better for Samba too)
3257 * while still recognizing old Windows style symlinks.
3258 */
3259 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003260 }
Steve Frenchdb8b6312014-09-22 05:13:55 -05003261 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003262 }
Steve French3b795212008-11-13 19:45:32 +00003263
3264 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesf96637b2013-05-04 22:12:25 -05003265 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003266}
3267
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003268static void
3269cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003270{
Sean Finneyb9468452011-04-11 13:19:32 +00003271 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003272 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003273 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003274 kfree(volume_info->domainname);
3275 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003276 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003277}
3278
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003279void
3280cifs_cleanup_volume_info(struct smb_vol *volume_info)
3281{
3282 if (!volume_info)
3283 return;
3284 cleanup_volume_info_contents(volume_info);
3285 kfree(volume_info);
3286}
3287
3288
Steve French2d6d5892009-04-09 00:36:44 +00003289#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003290/*
3291 * cifs_build_path_to_root returns full path to root when we do not have an
3292 * exiting connection (tcon)
3293 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003294static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003295build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003296 const struct cifs_sb_info *cifs_sb)
3297{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003298 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003299 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003300 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003301
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003302 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003303 if (full_path == NULL)
3304 return ERR_PTR(-ENOMEM);
3305
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003306 strncpy(full_path, vol->UNC, unc_len);
3307 pos = full_path + unc_len;
3308
3309 if (pplen) {
Jeff Layton1fc29ba2013-05-31 10:00:18 -04003310 *pos = CIFS_DIR_SEP(cifs_sb);
3311 strncpy(pos + 1, vol->prepath, pplen);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003312 pos += pplen;
3313 }
3314
3315 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003316 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05003317 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003318 return full_path;
3319}
Sean Finneydd613942011-04-11 13:19:30 +00003320
3321/*
3322 * Perform a dfs referral query for a share and (optionally) prefix
3323 *
Sean Finney046462a2011-04-11 13:19:33 +00003324 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3325 * to a string containing updated options for the submount. Otherwise it
3326 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003327 *
3328 * Returns the rc from get_dfs_path to the caller, which can be used to
3329 * determine whether there were referrals.
3330 */
3331static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003332expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003333 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003334 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003335{
3336 int rc;
3337 unsigned int num_referrals = 0;
3338 struct dfs_info3_param *referrals = NULL;
3339 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3340
3341 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3342 if (IS_ERR(full_path))
3343 return PTR_ERR(full_path);
3344
3345 /* For DFS paths, skip the first '\' of the UNC */
3346 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3347
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003348 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Steve French2baa2682014-09-27 02:19:01 -05003349 &num_referrals, &referrals, cifs_remap(cifs_sb));
Sean Finneydd613942011-04-11 13:19:30 +00003350
3351 if (!rc && num_referrals > 0) {
3352 char *fake_devname = NULL;
3353
3354 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3355 full_path + 1, referrals,
3356 &fake_devname);
3357
3358 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003359
Sean Finneydd613942011-04-11 13:19:30 +00003360 if (IS_ERR(mdata)) {
3361 rc = PTR_ERR(mdata);
3362 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003363 } else {
3364 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003365 rc = cifs_setup_volume_info(volume_info, mdata,
3366 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003367 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003368 kfree(fake_devname);
3369 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003370 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003371 }
3372 kfree(full_path);
3373 return rc;
3374}
Steve French2d6d5892009-04-09 00:36:44 +00003375#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003376
Jeff Layton04db79b2011-07-06 08:10:38 -04003377static int
3378cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3379 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003381 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003382
Jeff Layton04db79b2011-07-06 08:10:38 -04003383 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3384 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003385
Jeff Layton7586b762008-12-01 18:41:49 -05003386 if (volume_info->nullauth) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003387 cifs_dbg(FYI, "Anonymous login\n");
Jeff Layton04febab2012-01-17 16:09:15 -05003388 kfree(volume_info->username);
3389 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003390 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391 /* BB fixme parse for domain name here */
Joe Perchesf96637b2013-05-04 22:12:25 -05003392 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003394 cifs_dbg(VFS, "No username specified\n");
Steve French50c2f752007-07-13 00:33:32 +00003395 /* In userspace mount helper we can get user name from alternate
3396 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003397 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 }
3399
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003401 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003402 /* load_nls_default cannot return null */
3403 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003405 volume_info->local_nls = load_nls(volume_info->iocharset);
3406 if (volume_info->local_nls == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003407 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003408 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003409 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003410 }
3411 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003412
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003413 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003414}
3415
3416struct smb_vol *
3417cifs_get_volume_info(char *mount_data, const char *devname)
3418{
3419 int rc;
3420 struct smb_vol *volume_info;
3421
Jeff Layton6ee95422012-11-26 11:09:57 -05003422 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003423 if (!volume_info)
3424 return ERR_PTR(-ENOMEM);
3425
3426 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3427 if (rc) {
3428 cifs_cleanup_volume_info(volume_info);
3429 volume_info = ERR_PTR(rc);
3430 }
3431
3432 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003433}
3434
3435int
Al Viro2c6292a2011-06-17 09:05:48 -04003436cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003437{
Jeff Layton1daaae82012-03-21 06:30:40 -04003438 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003439 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003440 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003441 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003442 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003443 char *full_path;
3444 struct tcon_link *tlink;
3445#ifdef CONFIG_CIFS_DFS_UPCALL
3446 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003447#endif
Al Virodd854462011-06-17 08:24:42 -04003448
3449 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3450 if (rc)
3451 return rc;
3452
Jeff Layton20547492011-07-09 12:21:07 -04003453#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003454try_mount_again:
3455 /* cleanup activities if we're chasing a referral */
3456 if (referral_walks_count) {
3457 if (tcon)
3458 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003459 else if (ses)
3460 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003461
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003462 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003463 }
3464#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003465 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003466 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003467 ses = NULL;
3468 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003469 full_path = NULL;
3470 tlink = NULL;
3471
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003472 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003473
Jeff Layton63c038c2008-12-01 18:41:46 -05003474 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003475 server = cifs_get_tcp_session(volume_info);
3476 if (IS_ERR(server)) {
3477 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003478 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003479 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 }
3481
Jeff Layton36988c72010-04-24 07:57:43 -04003482 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003483 ses = cifs_get_smb_ses(server, volume_info);
3484 if (IS_ERR(ses)) {
3485 rc = PTR_ERR(ses);
3486 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003487 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 }
Steve French50c2f752007-07-13 00:33:32 +00003489
Jeff Laytond00c28d2010-04-24 07:57:44 -04003490 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003491 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003492 if (IS_ERR(tcon)) {
3493 rc = PTR_ERR(tcon);
3494 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003495 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003496 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003497
Steve French6848b732011-05-26 18:38:54 +00003498 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003499 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003500 /* reset of caps checks mount to see if unix extensions
3501 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003502 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003503 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3504 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3505 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3506 rc = -EACCES;
3507 goto mount_fail_check;
3508 }
3509 } else
3510 tcon->unix_ext = 0; /* server does not support them */
3511
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003512 /* do not care if a following call succeed - informational */
3513 if (!tcon->ipc && server->ops->qfs_tcon)
3514 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003515
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003516 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3517 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003518
Jeff Layton66bfaad2011-10-19 15:30:35 -04003519 /* tune readahead according to rsize */
Jeff Layton8f714652012-05-01 17:41:49 -04003520 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003521
Igor Mammedove4cce942009-02-10 14:10:26 +03003522remote_path_check:
3523#ifdef CONFIG_CIFS_DFS_UPCALL
3524 /*
3525 * Perform an unconditional check for whether there are DFS
3526 * referrals for this path without prefix, to provide support
3527 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003528 * with PATH_NOT_COVERED to requests that include the prefix.
3529 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003530 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003531 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003532 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3533 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003534 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003535 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536 goto try_mount_again;
3537 }
3538 }
3539#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003540
Steve Frenchf87d39d2011-05-27 03:50:55 +00003541 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003542 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003543 if (!server->ops->is_path_accessible) {
3544 rc = -ENOSYS;
3545 goto mount_fail_check;
3546 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003547 /*
3548 * cifs_build_path_to_root works only when we have a valid tcon
3549 */
3550 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 if (full_path == NULL) {
3552 rc = -ENOMEM;
3553 goto mount_fail_check;
3554 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3556 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557 if (rc != 0 && rc != -EREMOTE) {
3558 kfree(full_path);
3559 goto mount_fail_check;
3560 }
3561 kfree(full_path);
3562 }
3563
3564 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003565 if (rc == -EREMOTE) {
3566#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003567 if (referral_walks_count > MAX_NESTED_LINKS) {
3568 /*
3569 * BB: when we implement proper loop detection,
3570 * we will remove this check. But now we need it
3571 * to prevent an indefinite loop if 'DFS tree' is
3572 * misconfigured (i.e. has loops).
3573 */
3574 rc = -ELOOP;
3575 goto mount_fail_check;
3576 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003577
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003578 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003579
Sean Finneydd613942011-04-11 13:19:30 +00003580 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003581 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003582 goto try_mount_again;
3583 }
Sean Finneydd613942011-04-11 13:19:30 +00003584 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003585#else /* No DFS support, return error on mount */
3586 rc = -EOPNOTSUPP;
3587#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003588 }
3589
Jeff Layton9d002df2010-10-06 19:51:11 -04003590 if (rc)
3591 goto mount_fail_check;
3592
3593 /* now, hang the tcon off of the superblock */
3594 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3595 if (tlink == NULL) {
3596 rc = -ENOMEM;
3597 goto mount_fail_check;
3598 }
3599
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003600 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003601 tlink->tl_tcon = tcon;
3602 tlink->tl_time = jiffies;
3603 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3604 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3605
Jeff Layton413e6612010-10-28 13:33:38 -04003606 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003607 spin_lock(&cifs_sb->tlink_tree_lock);
3608 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3609 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003610
Jeff Laytonda472fc2012-03-23 14:40:53 -04003611 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003612 TLINK_IDLE_EXPIRE);
3613
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003614mount_fail_check:
3615 /* on error free sesinfo and tcon struct if needed */
3616 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003617 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003618 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003619 if (tcon)
3620 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003621 else if (ses)
3622 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003623 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003624 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003625 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003626 }
3627
Linus Torvalds1da177e2005-04-16 15:20:36 -07003628out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003629 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630 return rc;
3631}
3632
Jeff Layton8d1bca32011-06-11 21:17:10 -04003633/*
3634 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3635 * pointer may be NULL.
3636 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003638CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003639 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640 const struct nls_table *nls_codepage)
3641{
3642 struct smb_hdr *smb_buffer;
3643 struct smb_hdr *smb_buffer_response;
3644 TCONX_REQ *pSMB;
3645 TCONX_RSP *pSMBr;
3646 unsigned char *bcc_ptr;
3647 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003648 int length;
3649 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650
3651 if (ses == NULL)
3652 return -EIO;
3653
3654 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003655 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003656 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003657
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658 smb_buffer_response = smb_buffer;
3659
3660 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3661 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003662
Pavel Shilovsky88257362012-05-23 14:01:59 +04003663 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 smb_buffer->Uid = ses->Suid;
3665 pSMB = (TCONX_REQ *) smb_buffer;
3666 pSMBr = (TCONX_RSP *) smb_buffer_response;
3667
3668 pSMB->AndXCommand = 0xFF;
3669 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003670 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003671 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003672 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003673 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003674 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003675 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003676 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003677 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003678 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3679 specified as required (when that support is added to
3680 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003681 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003682 by Samba (not sure whether other servers allow
3683 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003684#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003685 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton3f618222013-06-12 19:52:14 -05003686 (ses->sectype == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003687 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003688 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003689 SECMODE_PW_ENCRYPT ? true : false,
3690 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003691 else
3692#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003693 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003694 bcc_ptr, nls_codepage);
Steve Frencheeac8042006-01-13 21:34:58 -08003695
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003696 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003697 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003698 /* must align unicode strings */
3699 *bcc_ptr = 0; /* null byte password */
3700 bcc_ptr++;
3701 }
Steve Frencheeac8042006-01-13 21:34:58 -08003702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703
Jeff Layton38d77c52013-05-26 07:01:00 -04003704 if (ses->server->sign)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3706
3707 if (ses->capabilities & CAP_STATUS32) {
3708 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3709 }
3710 if (ses->capabilities & CAP_DFS) {
3711 smb_buffer->Flags2 |= SMBFLG2_DFS;
3712 }
3713 if (ses->capabilities & CAP_UNICODE) {
3714 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3715 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003716 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003717 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003718 (/* server len*/ + 256 /* share len */), nls_codepage);
3719 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720 bcc_ptr += 2; /* skip trailing null */
3721 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 strcpy(bcc_ptr, tree);
3723 bcc_ptr += strlen(tree) + 1;
3724 }
3725 strcpy(bcc_ptr, "?????");
3726 bcc_ptr += strlen("?????");
3727 bcc_ptr += 1;
3728 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003729 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3730 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003731 pSMB->ByteCount = cpu_to_le16(count);
3732
Steve French133672e2007-11-13 22:41:37 +00003733 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003734 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003735
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736 /* above now done in SendReceive */
3737 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003738 bool is_unicode;
3739
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003741 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 tcon->tid = smb_buffer_response->Tid;
3743 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003744 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003745 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003746 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3747 is_unicode = true;
3748 else
3749 is_unicode = false;
3750
Jeff Laytoncc20c032009-04-30 07:16:21 -04003751
Steve French50c2f752007-07-13 00:33:32 +00003752 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003753 if (length == 3) {
3754 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3755 (bcc_ptr[2] == 'C')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003756 cifs_dbg(FYI, "IPC connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003757 tcon->ipc = 1;
3758 }
3759 } else if (length == 2) {
3760 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3761 /* the most common case */
Joe Perchesf96637b2013-05-04 22:12:25 -05003762 cifs_dbg(FYI, "disk share connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003763 }
3764 }
Steve French50c2f752007-07-13 00:33:32 +00003765 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003766 bytes_left -= (length + 1);
Zhao Hongjiang46b51d02013-06-24 01:57:47 -05003767 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
Jeff Laytoncc20c032009-04-30 07:16:21 -04003768
3769 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003770 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003771 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003772 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003773 nls_codepage);
3774
Joe Perchesf96637b2013-05-04 22:12:25 -05003775 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003776
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003777 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003778 (smb_buffer_response->WordCount == 7))
3779 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003780 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3781 else
3782 tcon->Flags = 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003783 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003785 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003786 ses->ipc_tid = smb_buffer_response->Tid;
3787 }
3788
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003789 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003790 return rc;
3791}
3792
Al Viro2e32cf52013-10-03 12:53:37 -04003793static void delayed_free(struct rcu_head *p)
3794{
3795 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3796 unload_nls(sbi->local_nls);
3797 kfree(sbi);
3798}
3799
Al Viro2a9b9952011-06-17 09:27:16 -04003800void
3801cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802{
Jeff Laytonb647c352010-10-28 11:16:44 -04003803 struct rb_root *root = &cifs_sb->tlink_tree;
3804 struct rb_node *node;
3805 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003806
Jeff Layton2de970f2010-10-06 19:51:12 -04003807 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3808
Jeff Laytonb647c352010-10-28 11:16:44 -04003809 spin_lock(&cifs_sb->tlink_tree_lock);
3810 while ((node = rb_first(root))) {
3811 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3812 cifs_get_tlink(tlink);
3813 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3814 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003815
Jeff Laytonb647c352010-10-28 11:16:44 -04003816 spin_unlock(&cifs_sb->tlink_tree_lock);
3817 cifs_put_tlink(tlink);
3818 spin_lock(&cifs_sb->tlink_tree_lock);
3819 }
3820 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003821
Al Virodd854462011-06-17 08:24:42 -04003822 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003823 kfree(cifs_sb->mountdata);
Al Viro2e32cf52013-10-03 12:53:37 -04003824 call_rcu(&cifs_sb->rcu, delayed_free);
Steve French50c2f752007-07-13 00:33:32 +00003825}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003826
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003827int
3828cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829{
3830 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003831 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003832
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003833 if (!server->ops->need_neg || !server->ops->negotiate)
3834 return -ENOSYS;
3835
Jeff Layton198b5682010-04-24 07:57:48 -04003836 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003837 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003838 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839
Pavel Shilovsky45275782012-05-17 17:53:29 +04003840 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003841
3842 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003843 if (rc == 0) {
3844 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003845 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003846 server->tcpStatus = CifsGood;
3847 else
3848 rc = -EHOSTDOWN;
3849 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 }
Steve French26b994f2008-08-06 05:11:33 +00003851
Jeff Layton198b5682010-04-24 07:57:48 -04003852 return rc;
3853}
Steve French26b994f2008-08-06 05:11:33 +00003854
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003855int
3856cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3857 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003858{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003859 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003860 struct TCP_Server_Info *server = ses->server;
3861
Jeff Layton198b5682010-04-24 07:57:48 -04003862 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003863 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003864 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003865
Joe Perchesf96637b2013-05-04 22:12:25 -05003866 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
Steve French96daf2b2011-05-27 04:34:02 +00003867 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003868
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003869 if (server->ops->sess_setup)
3870 rc = server->ops->sess_setup(xid, ses, nls_info);
3871
Shirish Pargaonkard4e63bd2013-08-29 08:35:09 -05003872 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003873 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003874
Linus Torvalds1da177e2005-04-16 15:20:36 -07003875 return rc;
3876}
3877
Jeff Layton8a8798a2012-01-17 16:09:15 -05003878static int
3879cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3880{
Jeff Layton3f618222013-06-12 19:52:14 -05003881 vol->sectype = ses->sectype;
3882
3883 /* krb5 is special, since we don't need username or pw */
3884 if (vol->sectype == Kerberos)
Jeff Layton8a8798a2012-01-17 16:09:15 -05003885 return 0;
Jeff Layton8a8798a2012-01-17 16:09:15 -05003886
3887 return cifs_set_cifscreds(vol, ses);
3888}
3889
Steve French96daf2b2011-05-27 04:34:02 +00003890static struct cifs_tcon *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003891cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
Jeff Layton9d002df2010-10-06 19:51:11 -04003892{
Jeff Layton8a8798a2012-01-17 16:09:15 -05003893 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00003894 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3895 struct cifs_ses *ses;
3896 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04003897 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04003898
3899 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03003900 if (vol_info == NULL)
3901 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04003902
Jeff Layton9d002df2010-10-06 19:51:11 -04003903 vol_info->local_nls = cifs_sb->local_nls;
3904 vol_info->linux_uid = fsuid;
3905 vol_info->cred_uid = fsuid;
3906 vol_info->UNC = master_tcon->treeName;
3907 vol_info->retry = master_tcon->retry;
3908 vol_info->nocase = master_tcon->nocase;
3909 vol_info->local_lease = master_tcon->local_lease;
3910 vol_info->no_linux_ext = !master_tcon->unix_ext;
Jeff Layton28e11bd2013-05-26 07:01:00 -04003911 vol_info->sectype = master_tcon->ses->sectype;
3912 vol_info->sign = master_tcon->ses->sign;
Jeff Layton9d002df2010-10-06 19:51:11 -04003913
Jeff Layton8a8798a2012-01-17 16:09:15 -05003914 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3915 if (rc) {
3916 tcon = ERR_PTR(rc);
3917 goto out;
3918 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003919
3920 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303921 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003922 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303923 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003924
3925 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3926 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00003927 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04003928 cifs_put_tcp_session(master_tcon->ses->server);
3929 goto out;
3930 }
3931
3932 tcon = cifs_get_tcon(ses, vol_info);
3933 if (IS_ERR(tcon)) {
3934 cifs_put_smb_ses(ses);
3935 goto out;
3936 }
3937
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003938 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04003939 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3940out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05003941 kfree(vol_info->username);
3942 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04003943 kfree(vol_info);
3944
3945 return tcon;
3946}
3947
Steve French96daf2b2011-05-27 04:34:02 +00003948struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003949cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3950{
3951 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3952}
3953
Jeff Laytonb647c352010-10-28 11:16:44 -04003954/* find and return a tlink with given uid */
3955static struct tcon_link *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003956tlink_rb_search(struct rb_root *root, kuid_t uid)
Jeff Laytonb647c352010-10-28 11:16:44 -04003957{
3958 struct rb_node *node = root->rb_node;
3959 struct tcon_link *tlink;
3960
3961 while (node) {
3962 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3963
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003964 if (uid_gt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003965 node = node->rb_left;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003966 else if (uid_lt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003967 node = node->rb_right;
3968 else
3969 return tlink;
3970 }
3971 return NULL;
3972}
3973
3974/* insert a tcon_link into the tree */
3975static void
3976tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3977{
3978 struct rb_node **new = &(root->rb_node), *parent = NULL;
3979 struct tcon_link *tlink;
3980
3981 while (*new) {
3982 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3983 parent = *new;
3984
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003985 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003986 new = &((*new)->rb_left);
3987 else
3988 new = &((*new)->rb_right);
3989 }
3990
3991 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3992 rb_insert_color(&new_tlink->tl_rbnode, root);
3993}
3994
Jeff Layton9d002df2010-10-06 19:51:11 -04003995/*
3996 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3997 * current task.
3998 *
3999 * If the superblock doesn't refer to a multiuser mount, then just return
4000 * the master tcon for the mount.
4001 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05304002 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04004003 * exists, then check to see if it's pending construction. If it is then wait
4004 * for construction to complete. Once it's no longer pending, check to see if
4005 * it failed and either return an error or retry construction, depending on
4006 * the timeout.
4007 *
4008 * If one doesn't exist then insert a new tcon_link struct into the tree and
4009 * try to construct a new one.
4010 */
4011struct tcon_link *
4012cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4013{
4014 int ret;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004015 kuid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004016 struct tcon_link *tlink, *newtlink;
4017
4018 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4019 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4020
4021 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004022 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004023 if (tlink)
4024 cifs_get_tlink(tlink);
4025 spin_unlock(&cifs_sb->tlink_tree_lock);
4026
4027 if (tlink == NULL) {
4028 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4029 if (newtlink == NULL)
4030 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004031 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004032 newtlink->tl_tcon = ERR_PTR(-EACCES);
4033 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4034 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4035 cifs_get_tlink(newtlink);
4036
Jeff Layton9d002df2010-10-06 19:51:11 -04004037 spin_lock(&cifs_sb->tlink_tree_lock);
4038 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004039 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004040 if (tlink) {
4041 cifs_get_tlink(tlink);
4042 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004043 kfree(newtlink);
4044 goto wait_for_construction;
4045 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004046 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004047 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4048 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004049 } else {
4050wait_for_construction:
4051 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
Jeff Layton9d002df2010-10-06 19:51:11 -04004052 TASK_INTERRUPTIBLE);
4053 if (ret) {
4054 cifs_put_tlink(tlink);
NeilBrown74316202014-07-07 15:16:04 +10004055 return ERR_PTR(-ERESTARTSYS);
Jeff Layton9d002df2010-10-06 19:51:11 -04004056 }
4057
4058 /* if it's good, return it */
4059 if (!IS_ERR(tlink->tl_tcon))
4060 return tlink;
4061
4062 /* return error if we tried this already recently */
4063 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4064 cifs_put_tlink(tlink);
4065 return ERR_PTR(-EACCES);
4066 }
4067
4068 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4069 goto wait_for_construction;
4070 }
4071
4072 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4073 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4074 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4075
4076 if (IS_ERR(tlink->tl_tcon)) {
4077 cifs_put_tlink(tlink);
4078 return ERR_PTR(-EACCES);
4079 }
4080
4081 return tlink;
4082}
Jeff Layton2de970f2010-10-06 19:51:12 -04004083
4084/*
4085 * periodic workqueue job that scans tcon_tree for a superblock and closes
4086 * out tcons.
4087 */
4088static void
4089cifs_prune_tlinks(struct work_struct *work)
4090{
4091 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4092 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004093 struct rb_root *root = &cifs_sb->tlink_tree;
4094 struct rb_node *node = rb_first(root);
4095 struct rb_node *tmp;
4096 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004097
Jeff Laytonb647c352010-10-28 11:16:44 -04004098 /*
4099 * Because we drop the spinlock in the loop in order to put the tlink
4100 * it's not guarded against removal of links from the tree. The only
4101 * places that remove entries from the tree are this function and
4102 * umounts. Because this function is non-reentrant and is canceled
4103 * before umount can proceed, this is safe.
4104 */
4105 spin_lock(&cifs_sb->tlink_tree_lock);
4106 node = rb_first(root);
4107 while (node != NULL) {
4108 tmp = node;
4109 node = rb_next(tmp);
4110 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4111
4112 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4113 atomic_read(&tlink->tl_count) != 0 ||
4114 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4115 continue;
4116
4117 cifs_get_tlink(tlink);
4118 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4119 rb_erase(tmp, root);
4120
Jeff Layton2de970f2010-10-06 19:51:12 -04004121 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004122 cifs_put_tlink(tlink);
4123 spin_lock(&cifs_sb->tlink_tree_lock);
4124 }
4125 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004126
Jeff Laytonda472fc2012-03-23 14:40:53 -04004127 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004128 TLINK_IDLE_EXPIRE);
4129}