blob: c4c6aa99ee1cbaafe52e44a2a6aae7cb4f0f1ba5 [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,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
76 Opt_nocase,
77 Opt_brl, Opt_nobrl,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
81 Opt_nointr, Opt_intr,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
Jeff Layton1b359202012-09-19 15:20:27 -070086 Opt_sign, Opt_seal, Opt_noac,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040087 Opt_fsc, Opt_mfsymlinks,
Jeff Laytona0b3df52013-05-24 07:40:59 -040088 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040089
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
95
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
Jeff Layton73a999f2013-03-22 08:42:57 -040098 Opt_domain, Opt_srcaddr, Opt_iocharset,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -040099 Opt_netbiosname, Opt_servern,
Jeff Layton23db65f2012-05-15 12:20:51 -0400100 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400101
102 /* Mount options to be ignored */
103 Opt_ignore,
104
105 /* Options which could be blank */
106 Opt_blank_pass,
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100107 Opt_blank_user,
108 Opt_blank_ip,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400109
110 Opt_err
111};
112
113static const match_table_t cifs_mount_option_tokens = {
114
115 { Opt_user_xattr, "user_xattr" },
116 { Opt_nouser_xattr, "nouser_xattr" },
117 { Opt_forceuid, "forceuid" },
118 { Opt_noforceuid, "noforceuid" },
Jeff Layton72bd4812012-10-03 16:02:36 -0400119 { Opt_forcegid, "forcegid" },
120 { Opt_noforcegid, "noforcegid" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400121 { Opt_noblocksend, "noblocksend" },
122 { Opt_noautotune, "noautotune" },
123 { Opt_hard, "hard" },
124 { Opt_soft, "soft" },
125 { Opt_perm, "perm" },
126 { Opt_noperm, "noperm" },
127 { Opt_mapchars, "mapchars" },
128 { Opt_nomapchars, "nomapchars" },
129 { Opt_sfu, "sfu" },
130 { Opt_nosfu, "nosfu" },
131 { Opt_nodfs, "nodfs" },
132 { Opt_posixpaths, "posixpaths" },
133 { Opt_noposixpaths, "noposixpaths" },
134 { Opt_nounix, "nounix" },
135 { Opt_nounix, "nolinux" },
136 { Opt_nocase, "nocase" },
137 { Opt_nocase, "ignorecase" },
138 { Opt_brl, "brl" },
139 { Opt_nobrl, "nobrl" },
140 { Opt_nobrl, "nolock" },
141 { Opt_forcemandatorylock, "forcemandatorylock" },
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +0400142 { Opt_forcemandatorylock, "forcemand" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400143 { Opt_setuids, "setuids" },
144 { Opt_nosetuids, "nosetuids" },
145 { Opt_dynperm, "dynperm" },
146 { Opt_nodynperm, "nodynperm" },
147 { Opt_nohard, "nohard" },
148 { Opt_nosoft, "nosoft" },
149 { Opt_nointr, "nointr" },
150 { Opt_intr, "intr" },
151 { Opt_nostrictsync, "nostrictsync" },
152 { Opt_strictsync, "strictsync" },
153 { Opt_serverino, "serverino" },
154 { Opt_noserverino, "noserverino" },
155 { Opt_rwpidforward, "rwpidforward" },
156 { Opt_cifsacl, "cifsacl" },
157 { Opt_nocifsacl, "nocifsacl" },
158 { Opt_acl, "acl" },
159 { Opt_noacl, "noacl" },
160 { Opt_locallease, "locallease" },
161 { Opt_sign, "sign" },
162 { Opt_seal, "seal" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400163 { Opt_noac, "noac" },
164 { Opt_fsc, "fsc" },
165 { Opt_mfsymlinks, "mfsymlinks" },
166 { Opt_multiuser, "multiuser" },
Jeff Laytond8162552012-03-23 14:40:56 -0400167 { Opt_sloppy, "sloppy" },
Jeff Laytona0b3df52013-05-24 07:40:59 -0400168 { Opt_nosharesock, "nosharesock" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400169
170 { Opt_backupuid, "backupuid=%s" },
171 { Opt_backupgid, "backupgid=%s" },
172 { Opt_uid, "uid=%s" },
173 { Opt_cruid, "cruid=%s" },
174 { Opt_gid, "gid=%s" },
175 { Opt_file_mode, "file_mode=%s" },
176 { Opt_dirmode, "dirmode=%s" },
177 { Opt_dirmode, "dir_mode=%s" },
178 { Opt_port, "port=%s" },
179 { Opt_rsize, "rsize=%s" },
180 { Opt_wsize, "wsize=%s" },
181 { Opt_actimeo, "actimeo=%s" },
182
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100183 { Opt_blank_user, "user=" },
184 { Opt_blank_user, "username=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400185 { Opt_user, "user=%s" },
186 { Opt_user, "username=%s" },
187 { Opt_blank_pass, "pass=" },
Jesper Nilsson3c15b4c2012-11-29 17:31:16 +0100188 { Opt_blank_pass, "password=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400189 { Opt_pass, "pass=%s" },
190 { Opt_pass, "password=%s" },
Sachin Prabhu4fe9e962012-04-10 18:12:27 +0100191 { Opt_blank_ip, "ip=" },
192 { Opt_blank_ip, "addr=" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400193 { Opt_ip, "ip=%s" },
194 { Opt_ip, "addr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400195 { Opt_ignore, "unc=%s" },
196 { Opt_ignore, "target=%s" },
197 { Opt_ignore, "path=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400198 { Opt_domain, "dom=%s" },
199 { Opt_domain, "domain=%s" },
200 { Opt_domain, "workgroup=%s" },
201 { Opt_srcaddr, "srcaddr=%s" },
Jeff Layton73a999f2013-03-22 08:42:57 -0400202 { Opt_ignore, "prefixpath=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400203 { Opt_iocharset, "iocharset=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400204 { Opt_netbiosname, "netbiosname=%s" },
205 { Opt_servern, "servern=%s" },
206 { Opt_ver, "ver=%s" },
Jeff Layton23db65f2012-05-15 12:20:51 -0400207 { Opt_vers, "vers=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400208 { Opt_sec, "sec=%s" },
Jeff Layton15b6a472012-05-16 07:50:15 -0400209 { Opt_cache, "cache=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400210
211 { Opt_ignore, "cred" },
212 { Opt_ignore, "credentials" },
Jeff Laytona557b972012-05-02 14:02:40 -0400213 { Opt_ignore, "cred=%s" },
214 { Opt_ignore, "credentials=%s" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400215 { Opt_ignore, "guest" },
216 { Opt_ignore, "rw" },
217 { Opt_ignore, "ro" },
218 { Opt_ignore, "suid" },
219 { Opt_ignore, "nosuid" },
220 { Opt_ignore, "exec" },
221 { Opt_ignore, "noexec" },
222 { Opt_ignore, "nodev" },
223 { Opt_ignore, "noauto" },
224 { Opt_ignore, "dev" },
225 { Opt_ignore, "mand" },
226 { Opt_ignore, "nomand" },
227 { Opt_ignore, "_netdev" },
228
229 { Opt_err, NULL }
230};
231
232enum {
233 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
234 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
Jeff Layton76596242012-07-23 20:34:17 -0400235 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
236 Opt_sec_ntlmv2i, Opt_sec_lanman,
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400237 Opt_sec_none,
238
239 Opt_sec_err
240};
241
242static const match_table_t cifs_secflavor_tokens = {
243 { Opt_sec_krb5, "krb5" },
244 { Opt_sec_krb5i, "krb5i" },
245 { Opt_sec_krb5p, "krb5p" },
246 { Opt_sec_ntlmsspi, "ntlmsspi" },
247 { Opt_sec_ntlmssp, "ntlmssp" },
248 { Opt_ntlm, "ntlm" },
249 { Opt_sec_ntlmi, "ntlmi" },
Jeff Layton76596242012-07-23 20:34:17 -0400250 { Opt_sec_ntlmv2, "nontlm" },
251 { Opt_sec_ntlmv2, "ntlmv2" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400252 { Opt_sec_ntlmv2i, "ntlmv2i" },
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400253 { Opt_sec_lanman, "lanman" },
254 { Opt_sec_none, "none" },
255
256 { Opt_sec_err, NULL }
257};
258
Jeff Layton15b6a472012-05-16 07:50:15 -0400259/* cache flavors */
260enum {
261 Opt_cache_loose,
262 Opt_cache_strict,
263 Opt_cache_none,
264 Opt_cache_err
265};
266
267static const match_table_t cifs_cacheflavor_tokens = {
268 { Opt_cache_loose, "loose" },
269 { Opt_cache_strict, "strict" },
270 { Opt_cache_none, "none" },
271 { Opt_cache_err, NULL }
272};
273
Jeff Layton23db65f2012-05-15 12:20:51 -0400274static const match_table_t cifs_smb_version_tokens = {
275 { Smb_1, SMB1_VERSION_STRING },
Steve Frenchdd446b12012-11-28 23:21:06 -0600276 { Smb_20, SMB20_VERSION_STRING},
Steve French1080ef72011-02-24 18:07:19 +0000277 { Smb_21, SMB21_VERSION_STRING },
Steve Frenche4aa25e2012-10-01 12:26:22 -0500278 { Smb_30, SMB30_VERSION_STRING },
Jeff Layton23db65f2012-05-15 12:20:51 -0400279};
280
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300281static int ip_connect(struct TCP_Server_Info *server);
282static int generic_ip_connect(struct TCP_Server_Info *server);
Jeff Laytonb647c352010-10-28 11:16:44 -0400283static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
Jeff Layton2de970f2010-10-06 19:51:12 -0400284static void cifs_prune_tlinks(struct work_struct *work);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -0400285static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
286 const char *devname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Jeff Laytond5c56052008-12-01 18:42:33 -0500288/*
289 * cifs tcp session reconnection
290 *
291 * mark tcp session as reconnecting so temporarily locked
292 * mark all smb sessions as reconnecting for tcp session
293 * reconnect tcp session
294 * wake up waiters on reconnection? - (not needed currently)
295 */
Pavel Shilovsky28ea5292012-05-23 16:18:00 +0400296int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297cifs_reconnect(struct TCP_Server_Info *server)
298{
299 int rc = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500300 struct list_head *tmp, *tmp2;
Steve French96daf2b2011-05-27 04:34:02 +0000301 struct cifs_ses *ses;
302 struct cifs_tcon *tcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000303 struct mid_q_entry *mid_entry;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400304 struct list_head retry_list;
Steve French50c2f752007-07-13 00:33:32 +0000305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000307 if (server->tcpStatus == CifsExiting) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000308 /* the demux thread will exit normally
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 next time through the loop */
310 spin_unlock(&GlobalMid_Lock);
311 return rc;
312 } else
313 server->tcpStatus = CifsNeedReconnect;
314 spin_unlock(&GlobalMid_Lock);
315 server->maxBuf = 0;
Pavel Shilovskyaa24d1e2011-12-27 16:23:34 +0400316#ifdef CONFIG_CIFS_SMB2
317 server->max_read = 0;
318#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Joe Perchesf96637b2013-05-04 22:12:25 -0500320 cifs_dbg(FYI, "Reconnecting tcp session\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322 /* before reconnecting the tcp session, mark the smb session (uid)
323 and the tid bad so they are not used until reconnected */
Joe Perchesf96637b2013-05-04 22:12:25 -0500324 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
325 __func__);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530326 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -0500327 list_for_each(tmp, &server->smb_ses_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000328 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
Jeff Layton14fbf502008-11-14 13:53:46 -0500329 ses->need_reconnect = true;
330 ses->ipc_tid = 0;
Jeff Laytonf1987b42008-11-15 11:12:47 -0500331 list_for_each(tmp2, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +0000332 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
Jeff Laytonf1987b42008-11-15 11:12:47 -0500333 tcon->need_reconnect = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +0530336 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 /* do not want to be sending data on a socket we are freeing */
Joe Perchesf96637b2013-05-04 22:12:25 -0500339 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
Jeff Layton72ca5452008-12-01 07:09:36 -0500340 mutex_lock(&server->srv_mutex);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000341 if (server->ssocket) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500342 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
343 server->ssocket->state, server->ssocket->flags);
Trond Myklebust91cf45f2007-11-12 18:10:39 -0800344 kernel_sock_shutdown(server->ssocket, SHUT_WR);
Joe Perchesf96637b2013-05-04 22:12:25 -0500345 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
346 server->ssocket->state, server->ssocket->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 sock_release(server->ssocket);
348 server->ssocket = NULL;
349 }
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -0500350 server->sequence_number = 0;
351 server->session_estab = false;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -0500352 kfree(server->session_key.response);
353 server->session_key.response = NULL;
354 server->session_key.len = 0;
Steve Frenchfda35942011-01-20 18:06:34 +0000355 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500356 mutex_unlock(&server->srv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500358 /* mark submitted MIDs for retry and issue callback */
Jeff Layton3c1105d2011-05-22 07:09:13 -0400359 INIT_LIST_HEAD(&retry_list);
Joe Perchesf96637b2013-05-04 22:12:25 -0500360 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 spin_lock(&GlobalMid_Lock);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500362 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
363 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400364 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
365 mid_entry->mid_state = MID_RETRY_NEEDED;
Jeff Layton3c1105d2011-05-22 07:09:13 -0400366 list_move(&mid_entry->qhead, &retry_list);
367 }
368 spin_unlock(&GlobalMid_Lock);
369
Joe Perchesf96637b2013-05-04 22:12:25 -0500370 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
Jeff Layton3c1105d2011-05-22 07:09:13 -0400371 list_for_each_safe(tmp, tmp2, &retry_list) {
372 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500373 list_del_init(&mid_entry->qhead);
374 mid_entry->callback(mid_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400377 do {
Steve French6c3d8902006-07-31 22:46:20 +0000378 try_to_freeze();
Pavel Shilovskya9f1b852010-12-13 19:08:35 +0300379
380 /* we should try only the port we connected to before */
381 rc = generic_ip_connect(server);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000382 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500383 cifs_dbg(FYI, "reconnect error %d\n", rc);
Steve French0cb766a2005-04-28 22:41:11 -0700384 msleep(3000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 } else {
386 atomic_inc(&tcpSesReconnectCount);
387 spin_lock(&GlobalMid_Lock);
Jeff Layton469ee612008-10-16 18:46:39 +0000388 if (server->tcpStatus != CifsExiting)
Steve Frenchfd88ce92011-04-12 01:01:14 +0000389 server->tcpStatus = CifsNeedNegotiate;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000390 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 }
Jeff Layton7fdbaa12011-06-10 16:14:57 -0400392 } while (server->tcpStatus == CifsNeedReconnect);
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500393
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return rc;
395}
396
Jeff Laytonc74093b2011-01-11 07:24:23 -0500397static void
398cifs_echo_request(struct work_struct *work)
399{
400 int rc;
401 struct TCP_Server_Info *server = container_of(work,
402 struct TCP_Server_Info, echo.work);
403
Jeff Layton247ec9b2011-02-04 17:09:50 -0500404 /*
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400405 * We cannot send an echo if it is disabled or until the
406 * NEGOTIATE_PROTOCOL request is done, which is indicated by
407 * server->ops->need_neg() == true. Also, no need to ping if
408 * we got a response recently.
Jeff Layton247ec9b2011-02-04 17:09:50 -0500409 */
Pavel Shilovsky286170a2012-05-25 10:43:58 +0400410 if (!server->ops->need_neg || server->ops->need_neg(server) ||
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400411 (server->ops->can_echo && !server->ops->can_echo(server)) ||
Jeff Layton247ec9b2011-02-04 17:09:50 -0500412 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
Jeff Laytonc74093b2011-01-11 07:24:23 -0500413 goto requeue_echo;
414
Pavel Shilovskyf6d76172012-05-25 14:47:16 +0400415 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
Jeff Laytonc74093b2011-01-11 07:24:23 -0500416 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -0500417 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
418 server->hostname);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500419
420requeue_echo:
Jeff Laytonda472fc2012-03-23 14:40:53 -0400421 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -0500422}
423
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400424static bool
Jeff Layton2a37ef92011-10-19 15:29:23 -0400425allocate_buffers(struct TCP_Server_Info *server)
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400426{
Jeff Layton2a37ef92011-10-19 15:29:23 -0400427 if (!server->bigbuf) {
428 server->bigbuf = (char *)cifs_buf_get();
429 if (!server->bigbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500430 cifs_dbg(VFS, "No memory for large SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400431 msleep(3000);
432 /* retry will check if exiting */
433 return false;
434 }
Jeff Layton2a37ef92011-10-19 15:29:23 -0400435 } else if (server->large_buf) {
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400436 /* we are reusing a dirty large buf, clear its start */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400437 memset(server->bigbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400438 }
439
Jeff Layton2a37ef92011-10-19 15:29:23 -0400440 if (!server->smallbuf) {
441 server->smallbuf = (char *)cifs_small_buf_get();
442 if (!server->smallbuf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500443 cifs_dbg(VFS, "No memory for SMB response\n");
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400444 msleep(1000);
445 /* retry will check if exiting */
446 return false;
447 }
448 /* beginning of smb buffer is cleared in our buf_get */
449 } else {
450 /* if existing small buf clear beginning */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400451 memset(server->smallbuf, 0, HEADER_SIZE(server));
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400452 }
453
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400454 return true;
455}
456
Jeff Laytonba749e62011-10-11 06:41:32 -0400457static bool
458server_unresponsive(struct TCP_Server_Info *server)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400459{
Pavel Shilovsky6dae51a2012-02-21 16:50:23 +0300460 /*
461 * We need to wait 2 echo intervals to make sure we handle such
462 * situations right:
463 * 1s client sends a normal SMB request
464 * 2s client gets a response
465 * 30s echo workqueue job pops, and decides we got a response recently
466 * and don't need to send another
467 * ...
468 * 65s kernel_recvmsg times out, and we see that we haven't gotten
469 * a response in >60s.
470 */
471 if (server->tcpStatus == CifsGood &&
472 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500473 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n",
474 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ);
Jeff Laytonba749e62011-10-11 06:41:32 -0400475 cifs_reconnect(server);
476 wake_up(&server->response_q);
477 return true;
478 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400479
Jeff Laytonba749e62011-10-11 06:41:32 -0400480 return false;
481}
482
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400483/*
484 * kvec_array_init - clone a kvec array, and advance into it
485 * @new: pointer to memory for cloned array
486 * @iov: pointer to original array
487 * @nr_segs: number of members in original array
488 * @bytes: number of bytes to advance into the cloned array
489 *
490 * This function will copy the array provided in iov to a section of memory
491 * and advance the specified number of bytes into the new array. It returns
492 * the number of segments in the new array. "new" must be at least as big as
493 * the original iov array.
494 */
495static unsigned int
496kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
497 size_t bytes)
498{
499 size_t base = 0;
500
501 while (bytes || !iov->iov_len) {
502 int copy = min(bytes, iov->iov_len);
503
504 bytes -= copy;
505 base += copy;
506 if (iov->iov_len == base) {
507 iov++;
508 nr_segs--;
509 base = 0;
510 }
511 }
512 memcpy(new, iov, sizeof(*iov) * nr_segs);
513 new->iov_base += base;
514 new->iov_len -= base;
515 return nr_segs;
516}
517
Jeff Layton1041e3f2011-10-19 15:28:27 -0400518static struct kvec *
519get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
520{
521 struct kvec *new_iov;
522
523 if (server->iov && nr_segs <= server->nr_iov)
524 return server->iov;
525
526 /* not big enough -- allocate a new one and release the old */
527 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
528 if (new_iov) {
529 kfree(server->iov);
530 server->iov = new_iov;
531 server->nr_iov = nr_segs;
532 }
533 return new_iov;
534}
535
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400536int
537cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
538 unsigned int nr_segs, unsigned int to_read)
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400539{
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400540 int length = 0;
541 int total_read;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400542 unsigned int segs;
Jeff Laytone831e6c2011-10-11 06:41:32 -0400543 struct msghdr smb_msg;
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400544 struct kvec *iov;
545
Jeff Layton1041e3f2011-10-19 15:28:27 -0400546 iov = get_server_iovec(server, nr_segs);
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400547 if (!iov)
548 return -ENOMEM;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400549
Jeff Laytone831e6c2011-10-11 06:41:32 -0400550 smb_msg.msg_control = NULL;
551 smb_msg.msg_controllen = 0;
552
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400553 for (total_read = 0; to_read; total_read += length, to_read -= length) {
Jeff Layton95edcff2011-12-01 20:22:41 -0500554 try_to_freeze();
555
Jeff Laytonba749e62011-10-11 06:41:32 -0400556 if (server_unresponsive(server)) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400557 total_read = -EAGAIN;
Jeff Laytonba749e62011-10-11 06:41:32 -0400558 break;
559 }
560
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400561 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
562
563 length = kernel_recvmsg(server->ssocket, &smb_msg,
564 iov, segs, to_read, 0);
565
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400566 if (server->tcpStatus == CifsExiting) {
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400567 total_read = -ESHUTDOWN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400568 break;
569 } else if (server->tcpStatus == CifsNeedReconnect) {
570 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400571 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400572 break;
573 } else if (length == -ERESTARTSYS ||
574 length == -EAGAIN ||
575 length == -EINTR) {
576 /*
577 * Minimum sleep to prevent looping, allowing socket
578 * to clear and app threads to set tcpStatus
579 * CifsNeedReconnect if server hung.
580 */
581 usleep_range(1000, 2000);
582 length = 0;
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400583 continue;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400584 } else if (length <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500585 cifs_dbg(FYI, "Received no data or error: expecting %d\n"
586 "got %d", to_read, length);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400587 cifs_reconnect(server);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400588 total_read = -EAGAIN;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400589 break;
590 }
591 }
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400592 return total_read;
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400593}
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400594
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400595int
596cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
597 unsigned int to_read)
Jeff Layton42c4dfc2011-10-19 15:28:17 -0400598{
599 struct kvec iov;
600
601 iov.iov_base = buf;
602 iov.iov_len = to_read;
603
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400604 return cifs_readv_from_socket(server, &iov, 1, to_read);
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400605}
606
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400607static bool
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400608is_smb_response(struct TCP_Server_Info *server, unsigned char type)
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400609{
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400610 /*
611 * The first byte big endian of the length field,
612 * is actually not part of the length but the type
613 * with the most common, zero, as regular data.
614 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400615 switch (type) {
616 case RFC1002_SESSION_MESSAGE:
617 /* Regular SMB response */
618 return true;
619 case RFC1002_SESSION_KEEP_ALIVE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500620 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400621 break;
622 case RFC1002_POSITIVE_SESSION_RESPONSE:
Joe Perchesf96637b2013-05-04 22:12:25 -0500623 cifs_dbg(FYI, "RFC 1002 positive session response\n");
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400624 break;
625 case RFC1002_NEGATIVE_SESSION_RESPONSE:
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400626 /*
627 * We get this from Windows 98 instead of an error on
628 * SMB negprot response.
629 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500630 cifs_dbg(FYI, "RFC 1002 negative session response\n");
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400631 /* give server a second to clean up */
632 msleep(1000);
633 /*
634 * Always try 445 first on reconnect since we get NACK
635 * on some if we ever connected to port 139 (the NACK
636 * is since we do not begin with RFC1001 session
637 * initialize frame).
638 */
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400639 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400640 cifs_reconnect(server);
641 wake_up(&server->response_q);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400642 break;
643 default:
Joe Perchesf96637b2013-05-04 22:12:25 -0500644 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400645 cifs_reconnect(server);
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400646 }
647
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400648 return false;
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400649}
650
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400651void
652dequeue_mid(struct mid_q_entry *mid, bool malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400653{
654#ifdef CONFIG_CIFS_STATS2
655 mid->when_received = jiffies;
656#endif
657 spin_lock(&GlobalMid_Lock);
658 if (!malformed)
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400659 mid->mid_state = MID_RESPONSE_RECEIVED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400660 else
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400661 mid->mid_state = MID_RESPONSE_MALFORMED;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400662 list_del_init(&mid->qhead);
663 spin_unlock(&GlobalMid_Lock);
664}
665
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400666static void
667handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400668 char *buf, int malformed)
Jeff Laytonea1f4502011-10-19 15:29:05 -0400669{
Pavel Shilovsky316cf942012-05-23 14:31:03 +0400670 if (server->ops->check_trans2 &&
671 server->ops->check_trans2(mid, server, buf, malformed))
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400672 return;
Jeff Laytonea1f4502011-10-19 15:29:05 -0400673 mid->resp_buf = buf;
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400674 mid->large_buf = server->large_buf;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400675 /* Was previous buf put in mpx struct for multi-rsp? */
676 if (!mid->multiRsp) {
677 /* smb buffer will be freed by user thread */
678 if (server->large_buf)
679 server->bigbuf = NULL;
680 else
681 server->smallbuf = NULL;
682 }
Jeff Laytonffc00e22011-10-19 15:29:13 -0400683 dequeue_mid(mid, malformed);
Pavel Shilovskyad69bae2011-08-01 13:19:43 +0400684}
685
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400686static void clean_demultiplex_info(struct TCP_Server_Info *server)
687{
688 int length;
689
690 /* take it off the list, if it's not already */
691 spin_lock(&cifs_tcp_ses_lock);
692 list_del_init(&server->tcp_ses_list);
693 spin_unlock(&cifs_tcp_ses_lock);
694
695 spin_lock(&GlobalMid_Lock);
696 server->tcpStatus = CifsExiting;
697 spin_unlock(&GlobalMid_Lock);
698 wake_up_all(&server->response_q);
699
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400700 /* check if we have blocked requests that need to free */
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300701 spin_lock(&server->req_lock);
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +0400702 if (server->credits <= 0)
703 server->credits = 1;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +0300704 spin_unlock(&server->req_lock);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400705 /*
706 * Although there should not be any requests blocked on this queue it
707 * can not hurt to be paranoid and try to wake up requests that may
708 * haven been blocked when more than 50 at time were on the wire to the
709 * same server - they now will see the session is in exit state and get
710 * out of SendReceive.
711 */
712 wake_up_all(&server->request_q);
713 /* give those requests time to exit */
714 msleep(125);
715
716 if (server->ssocket) {
717 sock_release(server->ssocket);
718 server->ssocket = NULL;
719 }
720
721 if (!list_empty(&server->pending_mid_q)) {
722 struct list_head dispose_list;
723 struct mid_q_entry *mid_entry;
724 struct list_head *tmp, *tmp2;
725
726 INIT_LIST_HEAD(&dispose_list);
727 spin_lock(&GlobalMid_Lock);
728 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
729 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500730 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky7c9421e2012-03-23 14:28:03 -0400731 mid_entry->mid_state = MID_SHUTDOWN;
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400732 list_move(&mid_entry->qhead, &dispose_list);
733 }
734 spin_unlock(&GlobalMid_Lock);
735
736 /* now walk dispose list and issue callbacks */
737 list_for_each_safe(tmp, tmp2, &dispose_list) {
738 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
Joe Perchesf96637b2013-05-04 22:12:25 -0500739 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400740 list_del_init(&mid_entry->qhead);
741 mid_entry->callback(mid_entry);
742 }
743 /* 1/8th of sec is more than enough time for them to exit */
744 msleep(125);
745 }
746
747 if (!list_empty(&server->pending_mid_q)) {
748 /*
749 * mpx threads have not exited yet give them at least the smb
750 * send timeout time for long ops.
751 *
752 * Due to delays on oplock break requests, we need to wait at
753 * least 45 seconds before giving up on a request getting a
754 * response and going ahead and killing cifsd.
755 */
Joe Perchesf96637b2013-05-04 22:12:25 -0500756 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400757 msleep(46000);
758 /*
759 * If threads still have not exited they are probably never
760 * coming home not much else we can do but free the memory.
761 */
762 }
763
764 kfree(server->hostname);
Jeff Layton1041e3f2011-10-19 15:28:27 -0400765 kfree(server->iov);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400766 kfree(server);
767
768 length = atomic_dec_return(&tcpSesAllocCount);
769 if (length > 0)
770 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
771 GFP_KERNEL);
772}
773
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400774static int
Jeff Laytone9097ab2011-10-19 15:29:40 -0400775standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
776{
777 int length;
778 char *buf = server->smallbuf;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400779 unsigned int pdu_length = get_rfc1002_length(buf);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400780
781 /* make sure this will fit in a large buffer */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400782 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500783 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400784 cifs_reconnect(server);
785 wake_up(&server->response_q);
786 return -EAGAIN;
787 }
788
789 /* switch to large buffer if too big for a small one */
790 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
791 server->large_buf = true;
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400792 memcpy(server->bigbuf, buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400793 buf = server->bigbuf;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400794 }
795
796 /* now read the rest */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400797 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
798 pdu_length - HEADER_SIZE(server) + 1 + 4);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400799 if (length < 0)
800 return length;
801 server->total_read += length;
802
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400803 dump_smb(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400804
805 /*
806 * We know that we received enough to get to the MID as we
807 * checked the pdu_length earlier. Now check to see
808 * if the rest of the header is OK. We borrow the length
809 * var for the rest of the loop to avoid a new stack var.
810 *
811 * 48 bytes is enough to display the header and a little bit
812 * into the payload for debugging purposes.
813 */
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400814 length = server->ops->check_message(buf, server->total_read);
Jeff Laytone9097ab2011-10-19 15:29:40 -0400815 if (length != 0)
816 cifs_dump_mem("Bad SMB: ", buf,
817 min_t(unsigned int, server->total_read, 48));
818
Pavel Shilovsky2e44b282012-09-18 16:20:33 -0700819 if (server->ops->is_status_pending &&
820 server->ops->is_status_pending(buf, server, length))
821 return -1;
822
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500823 if (!mid)
824 return length;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400825
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400826 handle_mid(mid, server, buf, length);
Jeff Laytonff4fa4a2012-02-07 06:31:05 -0500827 return 0;
Jeff Laytone9097ab2011-10-19 15:29:40 -0400828}
829
830static int
Al Viro7c97c202011-06-21 08:51:28 -0400831cifs_demultiplex_thread(void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832{
833 int length;
Al Viro7c97c202011-06-21 08:51:28 -0400834 struct TCP_Server_Info *server = p;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400835 unsigned int pdu_length;
836 char *buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 struct task_struct *task_to_wake = NULL;
838 struct mid_q_entry *mid_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 current->flags |= PF_MEMALLOC;
Joe Perchesf96637b2013-05-04 22:12:25 -0500841 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
Jeff Layton93d0ec82008-08-02 08:00:48 -0400842
843 length = atomic_inc_return(&tcpSesAllocCount);
844 if (length > 1)
Steve French26f57362007-08-30 22:09:15 +0000845 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
846 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Rafael J. Wysocki83144182007-07-17 04:03:35 -0700848 set_freezable();
Jeff Layton469ee612008-10-16 18:46:39 +0000849 while (server->tcpStatus != CifsExiting) {
Steve Frenchede13272005-08-30 20:10:14 -0700850 if (try_to_freeze())
851 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700852
Jeff Layton2a37ef92011-10-19 15:29:23 -0400853 if (!allocate_buffers(server))
Pavel Shilovsky3d9c2472011-08-01 13:19:40 +0400854 continue;
Steve Frenchb8643e12005-04-28 22:41:07 -0700855
Jeff Layton2a37ef92011-10-19 15:29:23 -0400856 server->large_buf = false;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400857 buf = server->smallbuf;
Steve Frenchf01d5e12007-08-30 21:13:31 +0000858 pdu_length = 4; /* enough to get RFC1001 header */
Steve Frenchfda35942011-01-20 18:06:34 +0000859
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400860 length = cifs_read_from_socket(server, buf, pdu_length);
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400861 if (length < 0)
Steve Frenchfda35942011-01-20 18:06:34 +0000862 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400863 server->total_read = length;
Steve French67010fb2005-04-28 22:41:09 -0700864
Pavel Shilovsky98bac622011-08-01 13:19:42 +0400865 /*
866 * The right amount was read from socket - 4 bytes,
867 * so we can now interpret the length field.
868 */
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400869 pdu_length = get_rfc1002_length(buf);
Steve French46810cb2005-04-28 22:41:09 -0700870
Joe Perchesf96637b2013-05-04 22:12:25 -0500871 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
Jeff Laytonfe11e4c2011-10-11 06:41:32 -0400872 if (!is_smb_response(server, buf[0]))
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000873 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700874
Jeff Layton89482a52011-10-19 15:28:57 -0400875 /* make sure we have enough to get to the MID */
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400876 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500877 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
878 pdu_length);
Jeff Layton89482a52011-10-19 15:28:57 -0400879 cifs_reconnect(server);
880 wake_up(&server->response_q);
881 continue;
Steve Frenche4eb2952005-04-28 22:41:09 -0700882 }
Pavel Shilovskye7015fb2011-08-01 13:19:41 +0400883
Jeff Layton89482a52011-10-19 15:28:57 -0400884 /* read down to the MID */
Jeff Laytone28bc5b2011-10-19 15:30:07 -0400885 length = cifs_read_from_socket(server, buf + 4,
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400886 HEADER_SIZE(server) - 1 - 4);
Jeff Layton89482a52011-10-19 15:28:57 -0400887 if (length < 0)
888 continue;
Jeff Layton2a37ef92011-10-19 15:29:23 -0400889 server->total_read += length;
Jeff Layton89482a52011-10-19 15:28:57 -0400890
Pavel Shilovsky8aa26f32012-05-17 13:25:35 +0400891 mid_entry = server->ops->find_mid(server, buf);
Jeff Laytonc8054eb2011-10-19 15:29:31 -0400892
Jeff Layton44d22d82011-10-19 15:29:49 -0400893 if (!mid_entry || !mid_entry->receive)
894 length = standard_receive3(server, mid_entry);
895 else
896 length = mid_entry->receive(server, mid_entry);
897
Jeff Laytona52c1eb2011-10-11 06:41:32 -0400898 if (length < 0)
Steve Frenche4eb2952005-04-28 22:41:09 -0700899 continue;
900
Pavel Shilovskyd4e48542012-03-23 14:28:02 -0400901 if (server->large_buf)
Jeff Laytone9097ab2011-10-19 15:29:40 -0400902 buf = server->bigbuf;
Steve Frenche4eb2952005-04-28 22:41:09 -0700903
Steve Frenchfda35942011-01-20 18:06:34 +0000904 server->lstrp = jiffies;
Jeff Layton2b84a36c2011-01-11 07:24:21 -0500905 if (mid_entry != NULL) {
Jeff Layton2a37ef92011-10-19 15:29:23 -0400906 if (!mid_entry->multiRsp || mid_entry->multiEnd)
907 mid_entry->callback(mid_entry);
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400908 } else if (!server->ops->is_oplock_break ||
909 !server->ops->is_oplock_break(buf, server)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500910 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
911 atomic_read(&midCount));
Pavel Shilovsky1887f602012-05-17 12:45:31 +0400912 cifs_dump_mem("Received Data is: ", buf,
913 HEADER_SIZE(server));
Steve French39798772006-05-31 22:40:51 +0000914#ifdef CONFIG_CIFS_DEBUG2
Pavel Shilovsky7f0adb52012-05-28 15:50:10 +0400915 if (server->ops->dump_detail)
916 server->ops->dump_detail(buf);
Steve French39798772006-05-31 22:40:51 +0000917 cifs_dump_mids(server);
918#endif /* CIFS_DEBUG2 */
Steve French50c2f752007-07-13 00:33:32 +0000919
Steve Frenche4eb2952005-04-28 22:41:09 -0700920 }
921 } /* end while !EXITING */
922
Justin P. Mattockfd62cb72011-02-24 22:15:02 -0800923 /* buffer usually freed in free_mid - need to free it here on exit */
Jeff Layton2a37ef92011-10-19 15:29:23 -0400924 cifs_buf_release(server->bigbuf);
925 if (server->smallbuf) /* no sense logging a debug message if NULL */
926 cifs_small_buf_release(server->smallbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400928 task_to_wake = xchg(&server->tsk, NULL);
Pavel Shilovsky762dfd12011-08-01 13:19:44 +0400929 clean_demultiplex_info(server);
Steve French50c2f752007-07-13 00:33:32 +0000930
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -0400931 /* if server->tsk was NULL then wait for a signal before exiting */
932 if (!task_to_wake) {
933 set_current_state(TASK_INTERRUPTIBLE);
934 while (!signal_pending(current)) {
935 schedule();
936 set_current_state(TASK_INTERRUPTIBLE);
937 }
938 set_current_state(TASK_RUNNING);
939 }
940
Jeff Layton0468a2c2008-12-01 07:09:35 -0500941 module_put_and_exit(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
943
Jeff Laytonc359cf32007-11-16 22:22:06 +0000944/* extract the host portion of the UNC string */
945static char *
946extract_hostname(const char *unc)
947{
948 const char *src;
949 char *dst, *delim;
950 unsigned int len;
951
952 /* skip double chars at beginning of string */
953 /* BB: check validity of these bytes? */
954 src = unc + 2;
955
956 /* delimiter between hostname and sharename is always '\\' now */
957 delim = strchr(src, '\\');
958 if (!delim)
959 return ERR_PTR(-EINVAL);
960
961 len = delim - src;
962 dst = kmalloc((len + 1), GFP_KERNEL);
963 if (dst == NULL)
964 return ERR_PTR(-ENOMEM);
965
966 memcpy(dst, src, len);
967 dst[len] = '\0';
968
969 return dst;
970}
971
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400972static int get_option_ul(substring_t args[], unsigned long *option)
973{
974 int rc;
975 char *string;
976
977 string = match_strdup(args);
978 if (string == NULL)
979 return -ENOMEM;
Sachin Prabhubfa890a2012-04-13 14:04:32 +0100980 rc = kstrtoul(string, 0, option);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -0400981 kfree(string);
982
983 return rc;
984}
985
Eric W. Biederman3da46562013-02-06 01:37:39 -0800986static int get_option_uid(substring_t args[], kuid_t *result)
987{
988 unsigned long value;
989 kuid_t uid;
990 int rc;
991
992 rc = get_option_ul(args, &value);
993 if (rc)
994 return rc;
995
996 uid = make_kuid(current_user_ns(), value);
997 if (!uid_valid(uid))
998 return -EINVAL;
999
1000 *result = uid;
1001 return 0;
1002}
1003
1004static int get_option_gid(substring_t args[], kgid_t *result)
1005{
1006 unsigned long value;
1007 kgid_t gid;
1008 int rc;
1009
1010 rc = get_option_ul(args, &value);
1011 if (rc)
1012 return rc;
1013
1014 gid = make_kgid(current_user_ns(), value);
1015 if (!gid_valid(gid))
1016 return -EINVAL;
1017
1018 *result = gid;
1019 return 0;
1020}
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001021
1022static int cifs_parse_security_flavors(char *value,
1023 struct smb_vol *vol)
1024{
1025
1026 substring_t args[MAX_OPT_ARGS];
1027
Jeff Layton1e3cc572013-06-10 17:12:23 -05001028 /*
1029 * With mount options, the last one should win. Reset any existing
1030 * settings back to default.
1031 */
1032 vol->sectype = Unspecified;
1033 vol->sign = false;
1034
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001035 switch (match_token(value, cifs_secflavor_tokens, args)) {
Jeff Layton3f618222013-06-12 19:52:14 -05001036 case Opt_sec_krb5p:
1037 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1038 return 1;
1039 case Opt_sec_krb5i:
1040 vol->sign = true;
1041 /* Fallthrough */
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001042 case Opt_sec_krb5:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001043 vol->sectype = Kerberos;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001044 break;
1045 case Opt_sec_ntlmsspi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001046 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001047 /* Fallthrough */
1048 case Opt_sec_ntlmssp:
1049 vol->sectype = RawNTLMSSP;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001050 break;
1051 case Opt_sec_ntlmi:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001052 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001053 /* Fallthrough */
1054 case Opt_ntlm:
1055 vol->sectype = NTLM;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001056 break;
1057 case Opt_sec_ntlmv2i:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001058 vol->sign = true;
Jeff Layton3f618222013-06-12 19:52:14 -05001059 /* Fallthrough */
1060 case Opt_sec_ntlmv2:
1061 vol->sectype = NTLMv2;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001062 break;
1063#ifdef CONFIG_CIFS_WEAK_PW_HASH
1064 case Opt_sec_lanman:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001065 vol->sectype = LANMAN;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001066 break;
1067#endif
1068 case Opt_sec_none:
1069 vol->nullauth = 1;
1070 break;
1071 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001072 cifs_dbg(VFS, "bad security option: %s\n", value);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001073 return 1;
1074 }
1075
1076 return 0;
1077}
1078
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079static int
Jeff Layton15b6a472012-05-16 07:50:15 -04001080cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1081{
1082 substring_t args[MAX_OPT_ARGS];
1083
1084 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1085 case Opt_cache_loose:
1086 vol->direct_io = false;
1087 vol->strict_io = false;
1088 break;
1089 case Opt_cache_strict:
1090 vol->direct_io = false;
1091 vol->strict_io = true;
1092 break;
1093 case Opt_cache_none:
1094 vol->direct_io = true;
1095 vol->strict_io = false;
1096 break;
1097 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001098 cifs_dbg(VFS, "bad cache= option: %s\n", value);
Jeff Layton15b6a472012-05-16 07:50:15 -04001099 return 1;
1100 }
1101 return 0;
1102}
1103
1104static int
Jeff Layton23db65f2012-05-15 12:20:51 -04001105cifs_parse_smb_version(char *value, struct smb_vol *vol)
1106{
1107 substring_t args[MAX_OPT_ARGS];
1108
1109 switch (match_token(value, cifs_smb_version_tokens, args)) {
1110 case Smb_1:
1111 vol->ops = &smb1_operations;
1112 vol->vals = &smb1_values;
1113 break;
Steve French1080ef72011-02-24 18:07:19 +00001114#ifdef CONFIG_CIFS_SMB2
Steve Frenchdd446b12012-11-28 23:21:06 -06001115 case Smb_20:
1116 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1117 vol->vals = &smb20_values;
1118 break;
Steve French1080ef72011-02-24 18:07:19 +00001119 case Smb_21:
1120 vol->ops = &smb21_operations;
1121 vol->vals = &smb21_values;
1122 break;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001123 case Smb_30:
Steve French38107d42012-12-08 22:08:06 -06001124 vol->ops = &smb30_operations;
Steve Frenche4aa25e2012-10-01 12:26:22 -05001125 vol->vals = &smb30_values;
1126 break;
Steve French1080ef72011-02-24 18:07:19 +00001127#endif
Jeff Layton23db65f2012-05-15 12:20:51 -04001128 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05001129 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
Jeff Layton23db65f2012-05-15 12:20:51 -04001130 return 1;
1131 }
1132 return 0;
1133}
1134
Jeff Laytond387a5c2012-12-10 06:10:46 -05001135/*
1136 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1137 * fields with the result. Returns 0 on success and an error otherwise.
1138 */
1139static int
1140cifs_parse_devname(const char *devname, struct smb_vol *vol)
1141{
1142 char *pos;
1143 const char *delims = "/\\";
1144 size_t len;
1145
1146 /* make sure we have a valid UNC double delimiter prefix */
1147 len = strspn(devname, delims);
1148 if (len != 2)
1149 return -EINVAL;
1150
1151 /* find delimiter between host and sharename */
1152 pos = strpbrk(devname + 2, delims);
1153 if (!pos)
1154 return -EINVAL;
1155
1156 /* skip past delimiter */
1157 ++pos;
1158
1159 /* now go until next delimiter or end of string */
1160 len = strcspn(pos, delims);
1161
1162 /* move "pos" up to delimiter or NULL */
1163 pos += len;
1164 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1165 if (!vol->UNC)
1166 return -ENOMEM;
1167
1168 convert_delimiter(vol->UNC, '\\');
1169
1170 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1171 if (!*pos++ || !*pos)
1172 return 0;
1173
1174 vol->prepath = kstrdup(pos, GFP_KERNEL);
1175 if (!vol->prepath)
1176 return -ENOMEM;
1177
1178 return 0;
1179}
1180
Jeff Layton23db65f2012-05-15 12:20:51 -04001181static int
Sean Finneyb9468452011-04-11 13:19:32 +00001182cifs_parse_mount_options(const char *mountdata, const char *devname,
Steve French50c2f752007-07-13 00:33:32 +00001183 struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184{
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001185 char *data, *end;
Vasily Averin957df452011-06-06 11:33:12 +04001186 char *mountdata_copy = NULL, *options;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 unsigned int temp_len, i, j;
1188 char separator[2];
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001189 short int override_uid = -1;
1190 short int override_gid = -1;
1191 bool uid_specified = false;
1192 bool gid_specified = false;
Jeff Laytond8162552012-03-23 14:40:56 -04001193 bool sloppy = false;
1194 char *invalid = NULL;
Jeff Layton88463992010-11-22 15:31:03 -05001195 char *nodename = utsname()->nodename;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001196 char *string = NULL;
1197 char *tmp_end, *value;
1198 char delim;
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001199 bool got_ip = false;
1200 unsigned short port = 0;
1201 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
1203 separator[0] = ',';
Steve French50c2f752007-07-13 00:33:32 +00001204 separator[1] = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001205 delim = separator[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
Jeff Layton6ee95422012-11-26 11:09:57 -05001207 /* ensure we always start with zeroed-out smb_vol */
1208 memset(vol, 0, sizeof(*vol));
1209
Jeff Layton88463992010-11-22 15:31:03 -05001210 /*
1211 * does not have to be perfect mapping since field is
1212 * informational, only used for servers that do not support
1213 * port 445 and it can be overridden at mount time
1214 */
Jeff Layton1397f2e2011-01-07 11:30:28 -05001215 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1216 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
Jeff Layton88463992010-11-22 15:31:03 -05001217 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1218
Jeff Layton1397f2e2011-01-07 11:30:28 -05001219 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
Steve Frencha10faeb22005-08-22 21:38:31 -07001220 /* null target name indicates to use *SMBSERVR default called name
1221 if we end up sending RFC1001 session initialize */
1222 vol->target_rfc1001_name[0] = 0;
Jeff Layton3e4b3e12010-07-19 18:00:17 -04001223 vol->cred_uid = current_uid();
1224 vol->linux_uid = current_uid();
David Howellsa001e5b2008-11-14 10:38:47 +11001225 vol->linux_gid = current_gid();
Jeff Laytonf55ed1a2009-05-26 16:28:11 -04001226
1227 /* default to only allowing write access to owner of the mount */
1228 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
1230 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
Jeremy Allisonac670552005-06-22 17:26:35 -07001231 /* default is always to request posix paths. */
1232 vol->posix_paths = 1;
Jeff Laytona0c92172009-05-27 15:40:47 -04001233 /* default to using server inode numbers where available */
1234 vol->server_ino = 1;
Jeremy Allisonac670552005-06-22 17:26:35 -07001235
Jeff Layton1b359202012-09-19 15:20:27 -07001236 /* default is to use strict cifs caching semantics */
1237 vol->strict_io = true;
1238
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05301239 vol->actimeo = CIFS_DEF_ACTIMEO;
1240
Jeff Layton23db65f2012-05-15 12:20:51 -04001241 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1242 vol->ops = &smb1_operations;
1243 vol->vals = &smb1_values;
1244
Sean Finneyb9468452011-04-11 13:19:32 +00001245 if (!mountdata)
1246 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Sean Finneyb9468452011-04-11 13:19:32 +00001248 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1249 if (!mountdata_copy)
1250 goto cifs_parse_mount_err;
1251
1252 options = mountdata_copy;
Pavel Shilovsky4906e502011-04-14 22:00:56 +04001253 end = options + strlen(options);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001254
Steve French50c2f752007-07-13 00:33:32 +00001255 if (strncmp(options, "sep=", 4) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001256 if (options[4] != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 separator[0] = options[4];
1258 options += 5;
1259 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001260 cifs_dbg(FYI, "Null separator not allowed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
1262 }
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001263 vol->backupuid_specified = false; /* no backup intent for a user */
1264 vol->backupgid_specified = false; /* no backup intent for a group */
Steve French50c2f752007-07-13 00:33:32 +00001265
Jeff Layton37d4f992013-05-24 07:40:05 -04001266 switch (cifs_parse_devname(devname, vol)) {
1267 case 0:
1268 break;
1269 case -ENOMEM:
1270 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1271 goto cifs_parse_mount_err;
1272 case -EINVAL:
1273 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1274 goto cifs_parse_mount_err;
1275 default:
1276 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1277 goto cifs_parse_mount_err;
Jeff Laytond387a5c2012-12-10 06:10:46 -05001278 }
1279
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 while ((data = strsep(&options, separator)) != NULL) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001281 substring_t args[MAX_OPT_ARGS];
1282 unsigned long option;
1283 int token;
1284
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 if (!*data)
1286 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001288 token = match_token(data, cifs_mount_option_tokens, args);
1289
1290 switch (token) {
1291
1292 /* Ingnore the following */
1293 case Opt_ignore:
1294 break;
1295
1296 /* Boolean values */
1297 case Opt_user_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 vol->no_xattr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001299 break;
1300 case Opt_nouser_xattr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 vol->no_xattr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001302 break;
1303 case Opt_forceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001304 override_uid = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001305 break;
1306 case Opt_noforceuid:
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001307 override_uid = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001308 break;
Jeff Layton72bd4812012-10-03 16:02:36 -04001309 case Opt_forcegid:
1310 override_gid = 1;
1311 break;
1312 case Opt_noforcegid:
1313 override_gid = 0;
1314 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001315 case Opt_noblocksend:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001316 vol->noblocksnd = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001317 break;
1318 case Opt_noautotune:
Steve Frenchedf1ae42008-10-29 00:47:57 +00001319 vol->noautotune = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001320 break;
1321 case Opt_hard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001323 break;
1324 case Opt_soft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001326 break;
1327 case Opt_perm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 vol->noperm = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001329 break;
1330 case Opt_noperm:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 vol->noperm = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001332 break;
1333 case Opt_mapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001334 vol->remap = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001335 break;
1336 case Opt_nomapchars:
Steve French6a0b4822005-04-28 22:41:05 -07001337 vol->remap = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001338 break;
1339 case Opt_sfu:
Steve French50c2f752007-07-13 00:33:32 +00001340 vol->sfu_emul = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001341 break;
1342 case Opt_nosfu:
Steve French50c2f752007-07-13 00:33:32 +00001343 vol->sfu_emul = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001344 break;
1345 case Opt_nodfs:
Steve French2c1b8612008-10-16 18:35:21 +00001346 vol->nodfs = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001347 break;
1348 case Opt_posixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001349 vol->posix_paths = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001350 break;
1351 case Opt_noposixpaths:
Jeremy Allisonac670552005-06-22 17:26:35 -07001352 vol->posix_paths = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001353 break;
1354 case Opt_nounix:
Steve Frenchc18c8422007-07-18 23:21:09 +00001355 vol->no_linux_ext = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001356 break;
1357 case Opt_nocase:
Steve French50c2f752007-07-13 00:33:32 +00001358 vol->nocase = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001359 break;
1360 case Opt_brl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001361 vol->nobrl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001362 break;
1363 case Opt_nobrl:
Steve Frenchc46fa8a2005-08-18 20:49:57 -07001364 vol->nobrl = 1;
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001365 /*
1366 * turn off mandatory locking in mode
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001367 * if remote locking is turned off since the
Pavel Shilovsky5cfdddc2012-03-27 20:51:15 +04001368 * local vfs will do advisory
1369 */
Steve French50c2f752007-07-13 00:33:32 +00001370 if (vol->file_mode ==
1371 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
Steve Frenchd3485d32005-08-19 11:04:29 -07001372 vol->file_mode = S_IALLUGO;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001373 break;
1374 case Opt_forcemandatorylock:
Steve French13a6e422008-12-02 17:24:33 +00001375 vol->mand_lock = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001376 break;
1377 case Opt_setuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 vol->setuids = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001379 break;
1380 case Opt_nosetuids:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 vol->setuids = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001382 break;
1383 case Opt_dynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001384 vol->dynperm = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001385 break;
1386 case Opt_nodynperm:
Jeff Laytond0a9c072008-05-12 22:23:49 +00001387 vol->dynperm = false;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001388 break;
1389 case Opt_nohard:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 vol->retry = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001391 break;
1392 case Opt_nosoft:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 vol->retry = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001394 break;
1395 case Opt_nointr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 vol->intr = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001397 break;
1398 case Opt_intr:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 vol->intr = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001400 break;
1401 case Opt_nostrictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001402 vol->nostrictsync = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001403 break;
1404 case Opt_strictsync:
Steve Frenchbe652442009-02-23 15:21:59 +00001405 vol->nostrictsync = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001406 break;
1407 case Opt_serverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 vol->server_ino = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001409 break;
1410 case Opt_noserverino:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 vol->server_ino = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001412 break;
1413 case Opt_rwpidforward:
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001414 vol->rwpidforward = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001415 break;
1416 case Opt_cifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001417 vol->cifs_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001418 break;
1419 case Opt_nocifsacl:
Steve French0a4b92c2006-01-12 15:44:21 -08001420 vol->cifs_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001421 break;
1422 case Opt_acl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 vol->no_psx_acl = 0;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001424 break;
1425 case Opt_noacl:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 vol->no_psx_acl = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001427 break;
1428 case Opt_locallease:
Steve French84210e92008-10-23 04:42:37 +00001429 vol->local_lease = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001430 break;
1431 case Opt_sign:
Jeff Layton1e3cc572013-06-10 17:12:23 -05001432 vol->sign = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001433 break;
1434 case Opt_seal:
Steve French95b1cb92008-05-15 16:44:38 +00001435 /* we do not do the following in secFlags because seal
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001436 * is a per tree connection (mount) not a per socket
1437 * or per-smb connection option in the protocol
1438 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1439 */
Steve French95b1cb92008-05-15 16:44:38 +00001440 vol->seal = 1;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001441 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001442 case Opt_noac:
Steve French50c2f752007-07-13 00:33:32 +00001443 printk(KERN_WARNING "CIFS: Mount option noac not "
1444 "supported. Instead set "
1445 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001446 break;
1447 case Opt_fsc:
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301448#ifndef CONFIG_CIFS_FSCACHE
Joe Perchesf96637b2013-05-04 22:12:25 -05001449 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001450 goto cifs_parse_mount_err;
Suresh Jayaraman607a5692010-11-24 17:49:05 +05301451#endif
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05301452 vol->fsc = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001453 break;
1454 case Opt_mfsymlinks:
Stefan Metzmacher736a3322010-07-30 14:56:00 +02001455 vol->mfsymlinks = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001456 break;
1457 case Opt_multiuser:
Jeff Layton0eb8a132010-10-06 19:51:12 -04001458 vol->multiuser = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001459 break;
Jeff Laytond8162552012-03-23 14:40:56 -04001460 case Opt_sloppy:
1461 sloppy = true;
1462 break;
Jeff Laytona0b3df52013-05-24 07:40:59 -04001463 case Opt_nosharesock:
1464 vol->nosharesock = true;
1465 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001466
1467 /* Numeric Values */
1468 case Opt_backupuid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001469 if (get_option_uid(args, &vol->backupuid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001470 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1471 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001472 goto cifs_parse_mount_err;
1473 }
1474 vol->backupuid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001475 break;
1476 case Opt_backupgid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001477 if (get_option_gid(args, &vol->backupgid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001478 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1479 __func__);
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05001480 goto cifs_parse_mount_err;
1481 }
1482 vol->backupgid_specified = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001483 break;
1484 case Opt_uid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001485 if (get_option_uid(args, &vol->linux_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001486 cifs_dbg(VFS, "%s: Invalid uid value\n",
1487 __func__);
Sean Finneyb9468452011-04-11 13:19:32 +00001488 goto cifs_parse_mount_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001490 uid_specified = true;
1491 break;
1492 case Opt_cruid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001493 if (get_option_uid(args, &vol->cred_uid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001494 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1495 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001496 goto cifs_parse_mount_err;
1497 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001498 break;
1499 case Opt_gid:
Eric W. Biederman3da46562013-02-06 01:37:39 -08001500 if (get_option_gid(args, &vol->linux_gid)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001501 cifs_dbg(VFS, "%s: Invalid gid value\n",
1502 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001503 goto cifs_parse_mount_err;
1504 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001505 gid_specified = true;
1506 break;
1507 case Opt_file_mode:
1508 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001509 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1510 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001511 goto cifs_parse_mount_err;
1512 }
1513 vol->file_mode = option;
1514 break;
1515 case Opt_dirmode:
1516 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001517 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1518 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001519 goto cifs_parse_mount_err;
1520 }
1521 vol->dir_mode = option;
1522 break;
1523 case Opt_port:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001524 if (get_option_ul(args, &option) ||
1525 option > USHRT_MAX) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001526 cifs_dbg(VFS, "%s: Invalid port value\n",
1527 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001528 goto cifs_parse_mount_err;
1529 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001530 port = (unsigned short)option;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001531 break;
1532 case Opt_rsize:
1533 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001534 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1535 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001536 goto cifs_parse_mount_err;
1537 }
1538 vol->rsize = option;
1539 break;
1540 case Opt_wsize:
1541 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001542 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1543 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001544 goto cifs_parse_mount_err;
1545 }
1546 vol->wsize = option;
1547 break;
1548 case Opt_actimeo:
1549 if (get_option_ul(args, &option)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001550 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1551 __func__);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001552 goto cifs_parse_mount_err;
1553 }
1554 vol->actimeo = HZ * option;
1555 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001556 cifs_dbg(VFS, "attribute cache timeout too large\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001557 goto cifs_parse_mount_err;
1558 }
1559 break;
1560
1561 /* String Arguments */
1562
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001563 case Opt_blank_user:
1564 /* null user, ie. anonymous authentication */
1565 vol->nullauth = 1;
1566 vol->username = NULL;
1567 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001568 case Opt_user:
1569 string = match_strdup(args);
1570 if (string == NULL)
1571 goto out_nomem;
1572
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001573 if (strnlen(string, MAX_USERNAME_SIZE) >
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001574 MAX_USERNAME_SIZE) {
1575 printk(KERN_WARNING "CIFS: username too long\n");
1576 goto cifs_parse_mount_err;
1577 }
1578 vol->username = kstrdup(string, GFP_KERNEL);
Joe Perchesf96637b2013-05-04 22:12:25 -05001579 if (!vol->username)
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001580 goto cifs_parse_mount_err;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001581 break;
1582 case Opt_blank_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001583 /* passwords have to be handled differently
1584 * to allow the character used for deliminator
1585 * to be passed within them
1586 */
1587
Sachin Prabhuc369c9a2013-04-09 18:17:41 +01001588 /*
1589 * Check if this is a case where the password
1590 * starts with a delimiter
1591 */
1592 tmp_end = strchr(data, '=');
1593 tmp_end++;
1594 if (!(tmp_end < end && tmp_end[1] == delim)) {
1595 /* No it is not. Set the password to NULL */
1596 vol->password = NULL;
1597 break;
1598 }
1599 /* Yes it is. Drop down to Opt_pass below.*/
1600 case Opt_pass:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001601 /* Obtain the value string */
1602 value = strchr(data, '=');
Sachin Prabhu10238072012-03-28 18:07:08 +01001603 value++;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001604
1605 /* Set tmp_end to end of the string */
1606 tmp_end = (char *) value + strlen(value);
1607
1608 /* Check if following character is the deliminator
1609 * If yes, we have encountered a double deliminator
1610 * reset the NULL character to the deliminator
1611 */
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301612 if (tmp_end < end && tmp_end[1] == delim) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001613 tmp_end[0] = delim;
1614
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301615 /* Keep iterating until we get to a single
1616 * deliminator OR the end
1617 */
1618 while ((tmp_end = strchr(tmp_end, delim))
1619 != NULL && (tmp_end[1] == delim)) {
1620 tmp_end = (char *) &tmp_end[2];
1621 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001622
Suresh Jayaramane73f8432012-06-12 07:15:50 +05301623 /* Reset var options to point to next element */
1624 if (tmp_end) {
1625 tmp_end[0] = '\0';
1626 options = (char *) &tmp_end[1];
1627 } else
1628 /* Reached the end of the mount option
1629 * string */
1630 options = end;
1631 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001632
1633 /* Now build new password string */
1634 temp_len = strlen(value);
1635 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1636 if (vol->password == NULL) {
1637 printk(KERN_WARNING "CIFS: no memory "
1638 "for password\n");
1639 goto cifs_parse_mount_err;
1640 }
1641
1642 for (i = 0, j = 0; i < temp_len; i++, j++) {
1643 vol->password[j] = value[i];
1644 if ((value[i] == delim) &&
1645 value[i+1] == delim)
1646 /* skip the second deliminator */
1647 i++;
1648 }
1649 vol->password[j] = '\0';
1650 break;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001651 case Opt_blank_ip:
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001652 /* FIXME: should this be an error instead? */
1653 got_ip = false;
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001654 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001655 case Opt_ip:
1656 string = match_strdup(args);
1657 if (string == NULL)
1658 goto out_nomem;
1659
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001660 if (!cifs_convert_address(dstaddr, string,
1661 strlen(string))) {
1662 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1663 string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001664 goto cifs_parse_mount_err;
1665 }
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001666 got_ip = true;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001667 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001668 case Opt_domain:
1669 string = match_strdup(args);
1670 if (string == NULL)
1671 goto out_nomem;
1672
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001673 if (strnlen(string, 256) == 256) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001674 printk(KERN_WARNING "CIFS: domain name too"
1675 " long\n");
1676 goto cifs_parse_mount_err;
1677 }
1678
1679 vol->domainname = kstrdup(string, GFP_KERNEL);
1680 if (!vol->domainname) {
1681 printk(KERN_WARNING "CIFS: no memory "
1682 "for domainname\n");
1683 goto cifs_parse_mount_err;
1684 }
Joe Perchesf96637b2013-05-04 22:12:25 -05001685 cifs_dbg(FYI, "Domain name set\n");
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001686 break;
1687 case Opt_srcaddr:
1688 string = match_strdup(args);
1689 if (string == NULL)
1690 goto out_nomem;
1691
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001692 if (!cifs_convert_address(
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001693 (struct sockaddr *)&vol->srcaddr,
1694 string, strlen(string))) {
1695 printk(KERN_WARNING "CIFS: Could not parse"
1696 " srcaddr: %s\n", string);
1697 goto cifs_parse_mount_err;
1698 }
1699 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001700 case Opt_iocharset:
1701 string = match_strdup(args);
1702 if (string == NULL)
1703 goto out_nomem;
1704
Sachin Prabhu4fe9e962012-04-10 18:12:27 +01001705 if (strnlen(string, 1024) >= 65) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001706 printk(KERN_WARNING "CIFS: iocharset name "
1707 "too long.\n");
1708 goto cifs_parse_mount_err;
1709 }
1710
1711 if (strnicmp(string, "default", 7) != 0) {
1712 vol->iocharset = kstrdup(string,
1713 GFP_KERNEL);
1714 if (!vol->iocharset) {
1715 printk(KERN_WARNING "CIFS: no memory"
1716 "for charset\n");
1717 goto cifs_parse_mount_err;
1718 }
1719 }
1720 /* if iocharset not set then load_nls_default
1721 * is used by caller
1722 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001723 cifs_dbg(FYI, "iocharset set to %s\n", string);
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001724 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001725 case Opt_netbiosname:
1726 string = match_strdup(args);
1727 if (string == NULL)
1728 goto out_nomem;
1729
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001730 memset(vol->source_rfc1001_name, 0x20,
1731 RFC1001_NAME_LEN);
1732 /*
1733 * FIXME: are there cases in which a comma can
1734 * be valid in workstation netbios name (and
1735 * need special handling)?
1736 */
1737 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1738 /* don't ucase netbiosname for user */
1739 if (string[i] == 0)
1740 break;
1741 vol->source_rfc1001_name[i] = string[i];
1742 }
1743 /* The string has 16th byte zero still from
1744 * set at top of the function
1745 */
1746 if (i == RFC1001_NAME_LEN && string[i] != 0)
1747 printk(KERN_WARNING "CIFS: netbiosname"
1748 " longer than 15 truncated.\n");
1749
1750 break;
1751 case Opt_servern:
1752 /* servernetbiosname specified override *SMBSERVER */
1753 string = match_strdup(args);
1754 if (string == NULL)
1755 goto out_nomem;
1756
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001757 /* last byte, type, is 0x20 for servr type */
1758 memset(vol->target_rfc1001_name, 0x20,
1759 RFC1001_NAME_LEN_WITH_NULL);
1760
1761 /* BB are there cases in which a comma can be
1762 valid in this workstation netbios name
1763 (and need special handling)? */
1764
1765 /* user or mount helper must uppercase the
1766 netbios name */
1767 for (i = 0; i < 15; i++) {
1768 if (string[i] == 0)
1769 break;
1770 vol->target_rfc1001_name[i] = string[i];
1771 }
1772 /* The string has 16th byte zero still from
1773 set at top of the function */
1774 if (i == RFC1001_NAME_LEN && string[i] != 0)
1775 printk(KERN_WARNING "CIFS: server net"
1776 "biosname longer than 15 truncated.\n");
1777 break;
1778 case Opt_ver:
1779 string = match_strdup(args);
1780 if (string == NULL)
1781 goto out_nomem;
1782
Jeff Layton5249af32012-05-15 12:04:03 -04001783 if (strnicmp(string, "1", 1) == 0) {
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001784 /* This is the default */
1785 break;
1786 }
1787 /* For all other value, error */
1788 printk(KERN_WARNING "CIFS: Invalid version"
1789 " specified\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001790 goto cifs_parse_mount_err;
Jeff Layton23db65f2012-05-15 12:20:51 -04001791 case Opt_vers:
1792 string = match_strdup(args);
1793 if (string == NULL)
1794 goto out_nomem;
1795
1796 if (cifs_parse_smb_version(string, vol) != 0)
1797 goto cifs_parse_mount_err;
1798 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001799 case Opt_sec:
1800 string = match_strdup(args);
1801 if (string == NULL)
1802 goto out_nomem;
1803
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001804 if (cifs_parse_security_flavors(string, vol) != 0)
1805 goto cifs_parse_mount_err;
1806 break;
Jeff Layton15b6a472012-05-16 07:50:15 -04001807 case Opt_cache:
1808 string = match_strdup(args);
1809 if (string == NULL)
1810 goto out_nomem;
1811
1812 if (cifs_parse_cache_flavor(string, vol) != 0)
1813 goto cifs_parse_mount_err;
1814 break;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001815 default:
Jeff Laytond8162552012-03-23 14:40:56 -04001816 /*
1817 * An option we don't recognize. Save it off for later
1818 * if we haven't already found one
1819 */
1820 if (!invalid)
1821 invalid = data;
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001822 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 }
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001824 /* Free up any allocated string */
1825 kfree(string);
1826 string = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001828
Jeff Laytond8162552012-03-23 14:40:56 -04001829 if (!sloppy && invalid) {
1830 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1831 goto cifs_parse_mount_err;
1832 }
1833
Jeff Layton8a8798a2012-01-17 16:09:15 -05001834#ifndef CONFIG_KEYS
1835 /* Muliuser mounts require CONFIG_KEYS support */
1836 if (vol->multiuser) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001837 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001838 goto cifs_parse_mount_err;
Jeff Layton0eb8a132010-10-06 19:51:12 -04001839 }
Jeff Layton8a8798a2012-01-17 16:09:15 -05001840#endif
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001841 if (!vol->UNC) {
Jeff Layton37d4f992013-05-24 07:40:05 -04001842 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
Jeff Laytone5e69ab2012-11-25 08:00:42 -05001843 goto cifs_parse_mount_err;
1844 }
Jeff Layton0eb8a132010-10-06 19:51:12 -04001845
Jeff Layton62a1a432012-12-10 06:10:45 -05001846 /* make sure UNC has a share name */
1847 if (!strchr(vol->UNC + 3, '\\')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001848 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
Jeff Layton62a1a432012-12-10 06:10:45 -05001849 goto cifs_parse_mount_err;
1850 }
1851
Jeff Laytonb979aaa2012-11-26 11:09:55 -05001852 if (!got_ip) {
1853 /* No ip= option specified? Try to get it from UNC */
1854 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1855 strlen(&vol->UNC[2]))) {
1856 printk(KERN_ERR "Unable to determine destination "
1857 "address.\n");
1858 goto cifs_parse_mount_err;
1859 }
1860 }
1861
1862 /* set the port that we got earlier */
1863 cifs_set_port(dstaddr, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
Jeff Layton9b9d6b242009-07-31 06:56:09 -04001865 if (uid_specified)
1866 vol->override_uid = override_uid;
1867 else if (override_uid == 1)
1868 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1869 "specified with no uid= option.\n");
1870
1871 if (gid_specified)
1872 vol->override_gid = override_gid;
1873 else if (override_gid == 1)
1874 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1875 "specified with no gid= option.\n");
1876
Sean Finneyb9468452011-04-11 13:19:32 +00001877 kfree(mountdata_copy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 return 0;
Sean Finneyb9468452011-04-11 13:19:32 +00001879
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001880out_nomem:
1881 printk(KERN_WARNING "Could not allocate temporary buffer\n");
Sean Finneyb9468452011-04-11 13:19:32 +00001882cifs_parse_mount_err:
Sachin Prabhu8830d7e2012-03-23 14:40:56 -04001883 kfree(string);
Sean Finneyb9468452011-04-11 13:19:32 +00001884 kfree(mountdata_copy);
1885 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886}
1887
Ben Greear3eb9a882010-09-01 17:06:02 -07001888/** Returns true if srcaddr isn't specified and rhs isn't
1889 * specified, or if srcaddr is specified and
1890 * matches the IP address of the rhs argument.
1891 */
Jeff Layton45151482010-07-06 20:43:02 -04001892static bool
Ben Greear3eb9a882010-09-01 17:06:02 -07001893srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1894{
1895 switch (srcaddr->sa_family) {
1896 case AF_UNSPEC:
1897 return (rhs->sa_family == AF_UNSPEC);
1898 case AF_INET: {
1899 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1900 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1901 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1902 }
1903 case AF_INET6: {
1904 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
Nickolai Zeldoviche3e27752013-01-16 21:36:17 -05001905 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
Ben Greear3eb9a882010-09-01 17:06:02 -07001906 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1907 }
1908 default:
1909 WARN_ON(1);
1910 return false; /* don't expect to be here */
1911 }
1912}
1913
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001914/*
1915 * If no port is specified in addr structure, we try to match with 445 port
1916 * and if it fails - with 139 ports. It should be called only if address
1917 * families of server and addr are equal.
1918 */
1919static bool
1920match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1921{
Steve French6da97912011-03-13 18:55:55 +00001922 __be16 port, *sport;
Pavel Shilovsky4b886132010-12-13 22:18:07 +03001923
1924 switch (addr->sa_family) {
1925 case AF_INET:
1926 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1927 port = ((struct sockaddr_in *) addr)->sin_port;
1928 break;
1929 case AF_INET6:
1930 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1931 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1932 break;
1933 default:
1934 WARN_ON(1);
1935 return false;
1936 }
1937
1938 if (!port) {
1939 port = htons(CIFS_PORT);
1940 if (port == *sport)
1941 return true;
1942
1943 port = htons(RFC1001_PORT);
1944 }
1945
1946 return port == *sport;
1947}
Ben Greear3eb9a882010-09-01 17:06:02 -07001948
1949static bool
1950match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1951 struct sockaddr *srcaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952{
Jeff Layton45151482010-07-06 20:43:02 -04001953 switch (addr->sa_family) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001954 case AF_INET: {
1955 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1956 struct sockaddr_in *srv_addr4 =
1957 (struct sockaddr_in *)&server->dstaddr;
1958
1959 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
Jeff Layton45151482010-07-06 20:43:02 -04001960 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001961 break;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001962 }
1963 case AF_INET6: {
1964 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1965 struct sockaddr_in6 *srv_addr6 =
1966 (struct sockaddr_in6 *)&server->dstaddr;
1967
Jeff Layton45151482010-07-06 20:43:02 -04001968 if (!ipv6_addr_equal(&addr6->sin6_addr,
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001969 &srv_addr6->sin6_addr))
Jeff Layton45151482010-07-06 20:43:02 -04001970 return false;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001971 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
Jeff Layton45151482010-07-06 20:43:02 -04001972 return false;
Jeff Layton45151482010-07-06 20:43:02 -04001973 break;
1974 }
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03001975 default:
1976 WARN_ON(1);
1977 return false; /* don't expect to be here */
1978 }
Jeff Layton45151482010-07-06 20:43:02 -04001979
Ben Greear3eb9a882010-09-01 17:06:02 -07001980 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1981 return false;
1982
Jeff Layton45151482010-07-06 20:43:02 -04001983 return true;
1984}
1985
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001986static bool
1987match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1988{
Jeff Layton3f618222013-06-12 19:52:14 -05001989 /*
1990 * The select_sectype function should either return the vol->sectype
1991 * that was specified, or "Unspecified" if that sectype was not
1992 * compatible with the given NEGOTIATE request.
1993 */
1994 if (select_sectype(server, vol->sectype) == Unspecified)
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001995 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04001996
Jeff Layton3f618222013-06-12 19:52:14 -05001997 /*
1998 * Now check if signing mode is acceptable. No need to check
1999 * global_secflags at this point since if MUST_SIGN is set then
2000 * the server->sign had better be too.
2001 */
Jeff Layton38d77c52013-05-26 07:01:00 -04002002 if (vol->sign && !server->sign)
2003 return false;
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002004
2005 return true;
2006}
2007
Jeff Layton9fa114f2012-11-26 11:09:57 -05002008static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002009{
Jeff Layton9fa114f2012-11-26 11:09:57 -05002010 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2011
Jeff Laytona0b3df52013-05-24 07:40:59 -04002012 if (vol->nosharesock)
2013 return 0;
2014
Jeff Layton23db65f2012-05-15 12:20:51 -04002015 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2016 return 0;
2017
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002018 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2019 return 0;
2020
2021 if (!match_address(server, addr,
2022 (struct sockaddr *)&vol->srcaddr))
2023 return 0;
2024
2025 if (!match_port(server, addr))
2026 return 0;
2027
2028 if (!match_security(server, vol))
2029 return 0;
2030
2031 return 1;
2032}
2033
Jeff Layton45151482010-07-06 20:43:02 -04002034static struct TCP_Server_Info *
Jeff Layton9fa114f2012-11-26 11:09:57 -05002035cifs_find_tcp_session(struct smb_vol *vol)
Jeff Layton45151482010-07-06 20:43:02 -04002036{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002037 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302039 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton45151482010-07-06 20:43:02 -04002040 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
Jeff Layton9fa114f2012-11-26 11:09:57 -05002041 if (!match_server(server, vol))
Jeff Laytondaf5b0b2010-07-06 20:43:02 -04002042 continue;
2043
Jeff Laytone7ddee92008-11-14 13:44:38 -05002044 ++server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302045 spin_unlock(&cifs_tcp_ses_lock);
Joe Perchesf96637b2013-05-04 22:12:25 -05002046 cifs_dbg(FYI, "Existing tcp session with server found\n");
Jeff Laytone7ddee92008-11-14 13:44:38 -05002047 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302049 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 return NULL;
2051}
2052
Jeff Layton14fbf502008-11-14 13:53:46 -05002053static void
Jeff Laytone7ddee92008-11-14 13:44:38 -05002054cifs_put_tcp_session(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055{
Jeff Laytone7ddee92008-11-14 13:44:38 -05002056 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302058 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002059 if (--server->srv_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302060 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002061 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 }
Steve Frenchdea570e02008-05-06 22:05:51 +00002063
Rob Landleyf1d0c992011-01-22 15:44:05 -06002064 put_net(cifs_net_ns(server));
2065
Jeff Laytone7ddee92008-11-14 13:44:38 -05002066 list_del_init(&server->tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302067 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytone7ddee92008-11-14 13:44:38 -05002068
Jeff Laytonc74093b2011-01-11 07:24:23 -05002069 cancel_delayed_work_sync(&server->echo);
2070
Jeff Laytone7ddee92008-11-14 13:44:38 -05002071 spin_lock(&GlobalMid_Lock);
2072 server->tcpStatus = CifsExiting;
2073 spin_unlock(&GlobalMid_Lock);
2074
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002075 cifs_crypto_shash_release(server);
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302076 cifs_fscache_release_client_cookie(server);
2077
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05002078 kfree(server->session_key.response);
2079 server->session_key.response = NULL;
2080 server->session_key.len = 0;
2081
Jeff Laytone7ddee92008-11-14 13:44:38 -05002082 task = xchg(&server->tsk, NULL);
2083 if (task)
2084 force_sig(SIGKILL, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085}
2086
Jeff Layton63c038c2008-12-01 18:41:46 -05002087static struct TCP_Server_Info *
2088cifs_get_tcp_session(struct smb_vol *volume_info)
2089{
2090 struct TCP_Server_Info *tcp_ses = NULL;
Jeff Layton63c038c2008-12-01 18:41:46 -05002091 int rc;
2092
Joe Perchesf96637b2013-05-04 22:12:25 -05002093 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
Jeff Layton63c038c2008-12-01 18:41:46 -05002094
2095 /* see if we already have a matching tcp_ses */
Jeff Layton9fa114f2012-11-26 11:09:57 -05002096 tcp_ses = cifs_find_tcp_session(volume_info);
Jeff Layton63c038c2008-12-01 18:41:46 -05002097 if (tcp_ses)
2098 return tcp_ses;
2099
2100 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2101 if (!tcp_ses) {
2102 rc = -ENOMEM;
2103 goto out_err;
2104 }
2105
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002106 rc = cifs_crypto_shash_allocate(tcp_ses);
2107 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002108 cifs_dbg(VFS, "could not setup hash structures rc %d\n", rc);
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002109 goto out_err;
2110 }
2111
Jeff Layton23db65f2012-05-15 12:20:51 -04002112 tcp_ses->ops = volume_info->ops;
2113 tcp_ses->vals = volume_info->vals;
Rob Landleyf1d0c992011-01-22 15:44:05 -06002114 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
Jeff Layton63c038c2008-12-01 18:41:46 -05002115 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2116 if (IS_ERR(tcp_ses->hostname)) {
2117 rc = PTR_ERR(tcp_ses->hostname);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002118 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002119 }
2120
2121 tcp_ses->noblocksnd = volume_info->noblocksnd;
2122 tcp_ses->noautotune = volume_info->noautotune;
Steve French6a5fa2362010-01-01 01:28:43 +00002123 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
Pavel Shilovskyfc40f9c2012-02-17 17:09:12 +03002124 tcp_ses->in_flight = 0;
Pavel Shilovsky2d86dbc2012-02-06 15:59:18 +04002125 tcp_ses->credits = 1;
Jeff Layton63c038c2008-12-01 18:41:46 -05002126 init_waitqueue_head(&tcp_ses->response_q);
2127 init_waitqueue_head(&tcp_ses->request_q);
2128 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2129 mutex_init(&tcp_ses->srv_mutex);
2130 memcpy(tcp_ses->workstation_RFC1001_name,
2131 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2132 memcpy(tcp_ses->server_RFC1001_name,
2133 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05002134 tcp_ses->session_estab = false;
Jeff Layton63c038c2008-12-01 18:41:46 -05002135 tcp_ses->sequence_number = 0;
Steve Frenchfda35942011-01-20 18:06:34 +00002136 tcp_ses->lstrp = jiffies;
Jeff Layton58fa0152012-05-01 17:41:16 -04002137 spin_lock_init(&tcp_ses->req_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002138 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2139 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002140 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
Jeff Layton9fa114f2012-11-26 11:09:57 -05002141 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2142 sizeof(tcp_ses->srcaddr));
2143 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2144 sizeof(tcp_ses->dstaddr));
Jeff Layton63c038c2008-12-01 18:41:46 -05002145 /*
2146 * at this point we are the only ones with the pointer
2147 * to the struct since the kernel thread not created yet
2148 * no need to spinlock this init of tcpStatus or srv_count
2149 */
2150 tcp_ses->tcpStatus = CifsNew;
2151 ++tcp_ses->srv_count;
2152
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002153 rc = ip_connect(tcp_ses);
Jeff Layton63c038c2008-12-01 18:41:46 -05002154 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002155 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002156 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002157 }
2158
2159 /*
2160 * since we're in a cifs function already, we know that
2161 * this will succeed. No need for try_module_get().
2162 */
2163 __module_get(THIS_MODULE);
Al Viro7c97c202011-06-21 08:51:28 -04002164 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
Jeff Layton63c038c2008-12-01 18:41:46 -05002165 tcp_ses, "cifsd");
2166 if (IS_ERR(tcp_ses->tsk)) {
2167 rc = PTR_ERR(tcp_ses->tsk);
Joe Perchesf96637b2013-05-04 22:12:25 -05002168 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
Jeff Layton63c038c2008-12-01 18:41:46 -05002169 module_put(THIS_MODULE);
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002170 goto out_err_crypto_release;
Jeff Layton63c038c2008-12-01 18:41:46 -05002171 }
Steve Frenchfd88ce92011-04-12 01:01:14 +00002172 tcp_ses->tcpStatus = CifsNeedNegotiate;
Jeff Layton63c038c2008-12-01 18:41:46 -05002173
2174 /* thread spawned, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302175 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002176 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302177 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton63c038c2008-12-01 18:41:46 -05002178
Suresh Jayaraman488f1d2d2010-07-05 18:12:15 +05302179 cifs_fscache_get_client_cookie(tcp_ses);
2180
Jeff Laytonc74093b2011-01-11 07:24:23 -05002181 /* queue echo request delayed work */
Jeff Laytonda472fc2012-03-23 14:40:53 -04002182 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
Jeff Laytonc74093b2011-01-11 07:24:23 -05002183
Jeff Layton63c038c2008-12-01 18:41:46 -05002184 return tcp_ses;
2185
Shirish Pargaonkarf7c54452010-10-26 18:10:24 -05002186out_err_crypto_release:
Shirish Pargaonkard2b91522010-10-21 14:25:08 -05002187 cifs_crypto_shash_release(tcp_ses);
2188
Rob Landleyf1d0c992011-01-22 15:44:05 -06002189 put_net(cifs_net_ns(tcp_ses));
2190
Jeff Layton63c038c2008-12-01 18:41:46 -05002191out_err:
2192 if (tcp_ses) {
Steve French8347a5c2009-10-06 18:31:29 +00002193 if (!IS_ERR(tcp_ses->hostname))
2194 kfree(tcp_ses->hostname);
Jeff Layton63c038c2008-12-01 18:41:46 -05002195 if (tcp_ses->ssocket)
2196 sock_release(tcp_ses->ssocket);
2197 kfree(tcp_ses);
2198 }
2199 return ERR_PTR(rc);
2200}
2201
Steve French96daf2b2011-05-27 04:34:02 +00002202static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002203{
Jeff Layton3f618222013-06-12 19:52:14 -05002204 if (vol->sectype != Unspecified &&
2205 vol->sectype != ses->sectype)
2206 return 0;
2207
2208 switch (ses->sectype) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002209 case Kerberos:
Eric W. Biederman64ed39d2013-02-06 02:30:39 -08002210 if (!uid_eq(vol->cred_uid, ses->cred_uid))
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002211 return 0;
2212 break;
2213 default:
Jeff Layton04febab2012-01-17 16:09:15 -05002214 /* NULL username means anonymous session */
2215 if (ses->user_name == NULL) {
2216 if (!vol->nullauth)
2217 return 0;
2218 break;
2219 }
2220
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002221 /* anything else takes username/password */
Jeff Layton04febab2012-01-17 16:09:15 -05002222 if (strncmp(ses->user_name,
2223 vol->username ? vol->username : "",
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002224 MAX_USERNAME_SIZE))
2225 return 0;
2226 if (strlen(vol->username) != 0 &&
2227 ses->password != NULL &&
2228 strncmp(ses->password,
2229 vol->password ? vol->password : "",
2230 MAX_PASSWORD_SIZE))
2231 return 0;
2232 }
2233 return 1;
2234}
2235
Steve French96daf2b2011-05-27 04:34:02 +00002236static struct cifs_ses *
Jeff Layton4ff67b72010-07-06 20:43:02 -04002237cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238{
Steve French96daf2b2011-05-27 04:34:02 +00002239 struct cifs_ses *ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302241 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton4ff67b72010-07-06 20:43:02 -04002242 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002243 if (!match_session(ses, vol))
2244 continue;
Jeff Layton14fbf502008-11-14 13:53:46 -05002245 ++ses->ses_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302246 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002247 return ses;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302249 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 return NULL;
2251}
2252
Jeff Layton14fbf502008-11-14 13:53:46 -05002253static void
Steve French96daf2b2011-05-27 04:34:02 +00002254cifs_put_smb_ses(struct cifs_ses *ses)
Jeff Layton14fbf502008-11-14 13:53:46 -05002255{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002256 unsigned int xid;
Jeff Layton14fbf502008-11-14 13:53:46 -05002257 struct TCP_Server_Info *server = ses->server;
2258
Joe Perchesf96637b2013-05-04 22:12:25 -05002259 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302260 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002261 if (--ses->ses_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302262 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002263 return;
2264 }
2265
2266 list_del_init(&ses->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302267 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton14fbf502008-11-14 13:53:46 -05002268
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002269 if (ses->status == CifsGood && server->ops->logoff) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002270 xid = get_xid();
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04002271 server->ops->logoff(xid, ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002272 _free_xid(xid);
Jeff Layton14fbf502008-11-14 13:53:46 -05002273 }
2274 sesInfoFree(ses);
2275 cifs_put_tcp_session(server);
2276}
2277
Jeff Layton8a8798a2012-01-17 16:09:15 -05002278#ifdef CONFIG_KEYS
2279
2280/* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2281#define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2282
2283/* Populate username and pw fields from keyring if possible */
2284static int
2285cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2286{
2287 int rc = 0;
2288 char *desc, *delim, *payload;
2289 ssize_t len;
2290 struct key *key;
2291 struct TCP_Server_Info *server = ses->server;
2292 struct sockaddr_in *sa;
2293 struct sockaddr_in6 *sa6;
2294 struct user_key_payload *upayload;
2295
2296 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2297 if (!desc)
2298 return -ENOMEM;
2299
2300 /* try to find an address key first */
2301 switch (server->dstaddr.ss_family) {
2302 case AF_INET:
2303 sa = (struct sockaddr_in *)&server->dstaddr;
2304 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2305 break;
2306 case AF_INET6:
2307 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2308 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2309 break;
2310 default:
Joe Perchesf96637b2013-05-04 22:12:25 -05002311 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2312 server->dstaddr.ss_family);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002313 rc = -EINVAL;
2314 goto out_err;
2315 }
2316
Joe Perchesf96637b2013-05-04 22:12:25 -05002317 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002318 key = request_key(&key_type_logon, desc, "");
2319 if (IS_ERR(key)) {
2320 if (!ses->domainName) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002321 cifs_dbg(FYI, "domainName is NULL\n");
Jeff Layton8a8798a2012-01-17 16:09:15 -05002322 rc = PTR_ERR(key);
2323 goto out_err;
2324 }
2325
2326 /* didn't work, try to find a domain key */
2327 sprintf(desc, "cifs:d:%s", ses->domainName);
Joe Perchesf96637b2013-05-04 22:12:25 -05002328 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002329 key = request_key(&key_type_logon, desc, "");
2330 if (IS_ERR(key)) {
2331 rc = PTR_ERR(key);
2332 goto out_err;
2333 }
2334 }
2335
2336 down_read(&key->sem);
2337 upayload = key->payload.data;
2338 if (IS_ERR_OR_NULL(upayload)) {
Jeff Layton4edc53c2012-02-07 06:30:51 -05002339 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
Jeff Layton8a8798a2012-01-17 16:09:15 -05002340 goto out_key_put;
2341 }
2342
2343 /* find first : in payload */
2344 payload = (char *)upayload->data;
2345 delim = strnchr(payload, upayload->datalen, ':');
Joe Perchesf96637b2013-05-04 22:12:25 -05002346 cifs_dbg(FYI, "payload=%s\n", payload);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002347 if (!delim) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002348 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2349 upayload->datalen);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002350 rc = -EINVAL;
2351 goto out_key_put;
2352 }
2353
2354 len = delim - payload;
2355 if (len > MAX_USERNAME_SIZE || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002356 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2357 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002358 rc = -EINVAL;
2359 goto out_key_put;
2360 }
2361
2362 vol->username = kstrndup(payload, len, GFP_KERNEL);
2363 if (!vol->username) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002364 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2365 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002366 rc = -ENOMEM;
2367 goto out_key_put;
2368 }
Joe Perchesf96637b2013-05-04 22:12:25 -05002369 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002370
2371 len = key->datalen - (len + 1);
2372 if (len > MAX_PASSWORD_SIZE || len <= 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002373 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002374 rc = -EINVAL;
2375 kfree(vol->username);
2376 vol->username = NULL;
2377 goto out_key_put;
2378 }
2379
2380 ++delim;
2381 vol->password = kstrndup(delim, len, GFP_KERNEL);
2382 if (!vol->password) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002383 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2384 len);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002385 rc = -ENOMEM;
2386 kfree(vol->username);
2387 vol->username = NULL;
2388 goto out_key_put;
2389 }
2390
2391out_key_put:
2392 up_read(&key->sem);
2393 key_put(key);
2394out_err:
2395 kfree(desc);
Joe Perchesf96637b2013-05-04 22:12:25 -05002396 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
Jeff Layton8a8798a2012-01-17 16:09:15 -05002397 return rc;
2398}
2399#else /* ! CONFIG_KEYS */
2400static inline int
2401cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2402 struct cifs_ses *ses __attribute__((unused)))
2403{
2404 return -ENOSYS;
2405}
2406#endif /* CONFIG_KEYS */
2407
Steve French96daf2b2011-05-27 04:34:02 +00002408static struct cifs_ses *
Jeff Layton36988c72010-04-24 07:57:43 -04002409cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2410{
Pavel Shilovsky286170a2012-05-25 10:43:58 +04002411 int rc = -ENOMEM;
2412 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002413 struct cifs_ses *ses;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002414 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2415 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
Jeff Layton36988c72010-04-24 07:57:43 -04002416
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002417 xid = get_xid();
Jeff Layton36988c72010-04-24 07:57:43 -04002418
Jeff Layton4ff67b72010-07-06 20:43:02 -04002419 ses = cifs_find_smb_ses(server, volume_info);
Jeff Layton36988c72010-04-24 07:57:43 -04002420 if (ses) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002421 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2422 ses->status);
Jeff Layton36988c72010-04-24 07:57:43 -04002423
Jeff Layton36988c72010-04-24 07:57:43 -04002424 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002425 rc = cifs_negotiate_protocol(xid, ses);
2426 if (rc) {
2427 mutex_unlock(&ses->session_mutex);
2428 /* problem -- put our ses reference */
2429 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002430 free_xid(xid);
Jeff Layton198b5682010-04-24 07:57:48 -04002431 return ERR_PTR(rc);
2432 }
Jeff Layton36988c72010-04-24 07:57:43 -04002433 if (ses->need_reconnect) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002434 cifs_dbg(FYI, "Session needs reconnect\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002435 rc = cifs_setup_session(xid, ses,
2436 volume_info->local_nls);
2437 if (rc) {
2438 mutex_unlock(&ses->session_mutex);
2439 /* problem -- put our reference */
2440 cifs_put_smb_ses(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002441 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002442 return ERR_PTR(rc);
2443 }
2444 }
2445 mutex_unlock(&ses->session_mutex);
Jeff Layton460cf342010-09-14 11:38:24 -04002446
2447 /* existing SMB ses has a server reference already */
2448 cifs_put_tcp_session(server);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002449 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002450 return ses;
2451 }
2452
Joe Perchesf96637b2013-05-04 22:12:25 -05002453 cifs_dbg(FYI, "Existing smb sess not found\n");
Jeff Layton36988c72010-04-24 07:57:43 -04002454 ses = sesInfoAlloc();
2455 if (ses == NULL)
2456 goto get_ses_fail;
2457
2458 /* new SMB session uses our server ref */
2459 ses->server = server;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002460 if (server->dstaddr.ss_family == AF_INET6)
2461 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002462 else
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002463 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
Jeff Layton36988c72010-04-24 07:57:43 -04002464
Steve French8727c8a2011-02-25 01:11:56 -06002465 if (volume_info->username) {
2466 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2467 if (!ses->user_name)
2468 goto get_ses_fail;
2469 }
Jeff Layton36988c72010-04-24 07:57:43 -04002470
2471 /* volume_info->password freed at unmount */
2472 if (volume_info->password) {
2473 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2474 if (!ses->password)
2475 goto get_ses_fail;
2476 }
2477 if (volume_info->domainname) {
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05002478 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2479 if (!ses->domainName)
2480 goto get_ses_fail;
Jeff Layton36988c72010-04-24 07:57:43 -04002481 }
Jeff Layton3e4b3e12010-07-19 18:00:17 -04002482 ses->cred_uid = volume_info->cred_uid;
Jeff Layton36988c72010-04-24 07:57:43 -04002483 ses->linux_uid = volume_info->linux_uid;
Steve Frenchd9b94202011-04-12 01:24:57 +00002484
Jeff Layton28e11bd2013-05-26 07:01:00 -04002485 ses->sectype = volume_info->sectype;
2486 ses->sign = volume_info->sign;
Jeff Layton36988c72010-04-24 07:57:43 -04002487
2488 mutex_lock(&ses->session_mutex);
Jeff Layton198b5682010-04-24 07:57:48 -04002489 rc = cifs_negotiate_protocol(xid, ses);
2490 if (!rc)
2491 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
Jeff Layton36988c72010-04-24 07:57:43 -04002492 mutex_unlock(&ses->session_mutex);
Steve Frenchc8e56f12010-09-08 21:10:58 +00002493 if (rc)
Jeff Layton36988c72010-04-24 07:57:43 -04002494 goto get_ses_fail;
2495
2496 /* success, put it on the list */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302497 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002498 list_add(&ses->smb_ses_list, &server->smb_ses_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302499 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton36988c72010-04-24 07:57:43 -04002500
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002501 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002502 return ses;
2503
2504get_ses_fail:
2505 sesInfoFree(ses);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002506 free_xid(xid);
Jeff Layton36988c72010-04-24 07:57:43 -04002507 return ERR_PTR(rc);
2508}
2509
Steve French96daf2b2011-05-27 04:34:02 +00002510static int match_tcon(struct cifs_tcon *tcon, const char *unc)
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002511{
2512 if (tcon->tidStatus == CifsExiting)
2513 return 0;
2514 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2515 return 0;
2516 return 1;
2517}
2518
Steve French96daf2b2011-05-27 04:34:02 +00002519static struct cifs_tcon *
2520cifs_find_tcon(struct cifs_ses *ses, const char *unc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521{
2522 struct list_head *tmp;
Steve French96daf2b2011-05-27 04:34:02 +00002523 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302525 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002526 list_for_each(tmp, &ses->tcon_list) {
Steve French96daf2b2011-05-27 04:34:02 +00002527 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
Pavel Shilovsky37bb04e2011-05-05 09:55:11 +00002528 if (!match_tcon(tcon, unc))
Jeff Laytonf1987b42008-11-15 11:12:47 -05002529 continue;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002530 ++tcon->tc_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302531 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 return tcon;
2533 }
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302534 spin_unlock(&cifs_tcp_ses_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 return NULL;
2536}
2537
Jeff Laytonf1987b42008-11-15 11:12:47 -05002538static void
Steve French96daf2b2011-05-27 04:34:02 +00002539cifs_put_tcon(struct cifs_tcon *tcon)
Jeff Laytonf1987b42008-11-15 11:12:47 -05002540{
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002541 unsigned int xid;
Steve French96daf2b2011-05-27 04:34:02 +00002542 struct cifs_ses *ses = tcon->ses;
Jeff Laytonf1987b42008-11-15 11:12:47 -05002543
Joe Perchesf96637b2013-05-04 22:12:25 -05002544 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302545 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002546 if (--tcon->tc_count > 0) {
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302547 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002548 return;
2549 }
2550
2551 list_del_init(&tcon->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302552 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002553
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002554 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002555 if (ses->server->ops->tree_disconnect)
2556 ses->server->ops->tree_disconnect(xid, tcon);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002557 _free_xid(xid);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002558
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302559 cifs_fscache_release_super_cookie(tcon);
Steve French9f841592010-07-23 20:37:53 +00002560 tconInfoFree(tcon);
Jeff Laytonf1987b42008-11-15 11:12:47 -05002561 cifs_put_smb_ses(ses);
2562}
2563
Steve French96daf2b2011-05-27 04:34:02 +00002564static struct cifs_tcon *
2565cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
Jeff Laytond00c28d2010-04-24 07:57:44 -04002566{
2567 int rc, xid;
Steve French96daf2b2011-05-27 04:34:02 +00002568 struct cifs_tcon *tcon;
Jeff Laytond00c28d2010-04-24 07:57:44 -04002569
2570 tcon = cifs_find_tcon(ses, volume_info->UNC);
2571 if (tcon) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002572 cifs_dbg(FYI, "Found match on UNC path\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002573 /* existing tcon already has a reference */
2574 cifs_put_smb_ses(ses);
2575 if (tcon->seal != volume_info->seal)
Joe Perchesf96637b2013-05-04 22:12:25 -05002576 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
Jeff Laytond00c28d2010-04-24 07:57:44 -04002577 return tcon;
2578 }
2579
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002580 if (!ses->server->ops->tree_connect) {
2581 rc = -ENOSYS;
2582 goto out_fail;
2583 }
2584
Jeff Laytond00c28d2010-04-24 07:57:44 -04002585 tcon = tconInfoAlloc();
2586 if (tcon == NULL) {
2587 rc = -ENOMEM;
2588 goto out_fail;
2589 }
2590
2591 tcon->ses = ses;
2592 if (volume_info->password) {
2593 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2594 if (!tcon->password) {
2595 rc = -ENOMEM;
2596 goto out_fail;
2597 }
2598 }
2599
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002600 /*
2601 * BB Do we need to wrap session_mutex around this TCon call and Unix
2602 * SetFS as we do on SessSetup and reconnect?
2603 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002604 xid = get_xid();
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002605 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2606 volume_info->local_nls);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002607 free_xid(xid);
Joe Perchesf96637b2013-05-04 22:12:25 -05002608 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002609 if (rc)
2610 goto out_fail;
2611
2612 if (volume_info->nodfs) {
2613 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
Joe Perchesf96637b2013-05-04 22:12:25 -05002614 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002615 }
2616 tcon->seal = volume_info->seal;
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002617 /*
2618 * We can have only one retry value for a connection to a share so for
2619 * resources mounted more than once to the same server share the last
2620 * value passed in for the retry flag is used.
2621 */
Jeff Laytond00c28d2010-04-24 07:57:44 -04002622 tcon->retry = volume_info->retry;
2623 tcon->nocase = volume_info->nocase;
2624 tcon->local_lease = volume_info->local_lease;
Pavel Shilovsky233839b2012-09-19 06:22:45 -07002625 INIT_LIST_HEAD(&tcon->pending_opens);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002626
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302627 spin_lock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002628 list_add(&tcon->tcon_list, &ses->tcon_list);
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05302629 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytond00c28d2010-04-24 07:57:44 -04002630
Suresh Jayaramand03382c2010-07-05 18:12:27 +05302631 cifs_fscache_get_super_cookie(tcon);
2632
Jeff Laytond00c28d2010-04-24 07:57:44 -04002633 return tcon;
2634
2635out_fail:
2636 tconInfoFree(tcon);
2637 return ERR_PTR(rc);
2638}
2639
Jeff Layton9d002df2010-10-06 19:51:11 -04002640void
2641cifs_put_tlink(struct tcon_link *tlink)
2642{
2643 if (!tlink || IS_ERR(tlink))
2644 return;
2645
2646 if (!atomic_dec_and_test(&tlink->tl_count) ||
2647 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2648 tlink->tl_time = jiffies;
2649 return;
2650 }
2651
2652 if (!IS_ERR(tlink_tcon(tlink)))
2653 cifs_put_tcon(tlink_tcon(tlink));
2654 kfree(tlink);
2655 return;
2656}
Jeff Laytond00c28d2010-04-24 07:57:44 -04002657
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002658static inline struct tcon_link *
Pavel Shilovskycd518752011-06-09 12:58:53 +04002659cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2660{
2661 return cifs_sb->master_tlink;
2662}
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002663
2664static int
2665compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2666{
2667 struct cifs_sb_info *old = CIFS_SB(sb);
2668 struct cifs_sb_info *new = mnt_data->cifs_sb;
2669
2670 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2671 return 0;
2672
2673 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2674 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2675 return 0;
2676
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002677 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002678 * We want to share sb only if we don't specify an r/wsize or
2679 * specified r/wsize is greater than or equal to existing one.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002680 */
2681 if (new->wsize && new->wsize < old->wsize)
2682 return 0;
2683
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002684 if (new->rsize && new->rsize < old->rsize)
2685 return 0;
2686
Eric W. Biederman1f682332013-02-06 01:20:20 -08002687 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002688 return 0;
2689
2690 if (old->mnt_file_mode != new->mnt_file_mode ||
2691 old->mnt_dir_mode != new->mnt_dir_mode)
2692 return 0;
2693
2694 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2695 return 0;
2696
2697 if (old->actimeo != new->actimeo)
2698 return 0;
2699
2700 return 1;
2701}
2702
2703int
2704cifs_match_super(struct super_block *sb, void *data)
2705{
2706 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2707 struct smb_vol *volume_info;
2708 struct cifs_sb_info *cifs_sb;
2709 struct TCP_Server_Info *tcp_srv;
Steve French96daf2b2011-05-27 04:34:02 +00002710 struct cifs_ses *ses;
2711 struct cifs_tcon *tcon;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002712 struct tcon_link *tlink;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002713 int rc = 0;
2714
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002715 spin_lock(&cifs_tcp_ses_lock);
2716 cifs_sb = CIFS_SB(sb);
2717 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2718 if (IS_ERR(tlink)) {
2719 spin_unlock(&cifs_tcp_ses_lock);
2720 return rc;
2721 }
2722 tcon = tlink_tcon(tlink);
2723 ses = tcon->ses;
2724 tcp_srv = ses->server;
2725
2726 volume_info = mnt_data->vol;
2727
Jeff Layton9fa114f2012-11-26 11:09:57 -05002728 if (!match_server(tcp_srv, volume_info) ||
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002729 !match_session(ses, volume_info) ||
2730 !match_tcon(tcon, volume_info->UNC)) {
2731 rc = 0;
2732 goto out;
2733 }
2734
2735 rc = compare_mount_options(sb, mnt_data);
2736out:
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002737 spin_unlock(&cifs_tcp_ses_lock);
Jeff Laytonf484b5d02011-07-11 10:16:34 -04002738 cifs_put_tlink(tlink);
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04002739 return rc;
2740}
2741
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002743get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002744 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2745 struct dfs_info3_param **referrals, int remap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746{
2747 char *temp_unc;
2748 int rc = 0;
2749
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002750 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002751 return -ENOSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002753 *num_referrals = 0;
2754 *referrals = NULL;
2755
2756 if (ses->ipc_tid == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 temp_unc = kmalloc(2 /* for slashes */ +
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002758 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2759 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 if (temp_unc == NULL)
2761 return -ENOMEM;
2762 temp_unc[0] = '\\';
2763 temp_unc[1] = '\\';
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002764 strcpy(temp_unc + 2, ses->serverName);
2765 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2766 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2767 nls_codepage);
Joe Perchesf96637b2013-05-04 22:12:25 -05002768 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 kfree(temp_unc);
2770 }
2771 if (rc == 0)
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002772 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2773 referrals, num_referrals,
2774 nls_codepage, remap);
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002775 /*
2776 * BB - map targetUNCs to dfs_info3 structures, here or in
Pavel Shilovskyb669f332012-05-27 20:21:53 +04002777 * ses->server->ops->get_dfs_refer.
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04002778 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779
2780 return rc;
2781}
2782
Jeff Layton09e50d52008-07-23 10:11:19 -04002783#ifdef CONFIG_DEBUG_LOCK_ALLOC
2784static struct lock_class_key cifs_key[2];
2785static struct lock_class_key cifs_slock_key[2];
2786
2787static inline void
2788cifs_reclassify_socket4(struct socket *sock)
2789{
2790 struct sock *sk = sock->sk;
2791 BUG_ON(sock_owned_by_user(sk));
2792 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2793 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2794}
2795
2796static inline void
2797cifs_reclassify_socket6(struct socket *sock)
2798{
2799 struct sock *sk = sock->sk;
2800 BUG_ON(sock_owned_by_user(sk));
2801 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2802 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2803}
2804#else
2805static inline void
2806cifs_reclassify_socket4(struct socket *sock)
2807{
2808}
2809
2810static inline void
2811cifs_reclassify_socket6(struct socket *sock)
2812{
2813}
2814#endif
2815
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816/* See RFC1001 section 14 on representation of Netbios names */
Steve French50c2f752007-07-13 00:33:32 +00002817static void rfc1002mangle(char *target, char *source, unsigned int length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818{
Steve French50c2f752007-07-13 00:33:32 +00002819 unsigned int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820
Steve French50c2f752007-07-13 00:33:32 +00002821 for (i = 0, j = 0; i < (length); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 /* mask a nibble at a time and encode */
2823 target[j] = 'A' + (0x0F & (source[i] >> 4));
2824 target[j+1] = 'A' + (0x0F & source[i]);
Steve French50c2f752007-07-13 00:33:32 +00002825 j += 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002826 }
2827
2828}
2829
Ben Greear3eb9a882010-09-01 17:06:02 -07002830static int
2831bind_socket(struct TCP_Server_Info *server)
2832{
2833 int rc = 0;
2834 if (server->srcaddr.ss_family != AF_UNSPEC) {
2835 /* Bind to the specified local IP address */
2836 struct socket *socket = server->ssocket;
2837 rc = socket->ops->bind(socket,
2838 (struct sockaddr *) &server->srcaddr,
2839 sizeof(server->srcaddr));
2840 if (rc < 0) {
2841 struct sockaddr_in *saddr4;
2842 struct sockaddr_in6 *saddr6;
2843 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2844 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2845 if (saddr6->sin6_family == AF_INET6)
Joe Perchesf96637b2013-05-04 22:12:25 -05002846 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2847 &saddr6->sin6_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002848 else
Joe Perchesf96637b2013-05-04 22:12:25 -05002849 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2850 &saddr4->sin_addr.s_addr, rc);
Ben Greear3eb9a882010-09-01 17:06:02 -07002851 }
2852 }
2853 return rc;
2854}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855
2856static int
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002857ip_rfc1001_connect(struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858{
2859 int rc = 0;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002860 /*
2861 * some servers require RFC1001 sessinit before sending
2862 * negprot - BB check reconnection in case where second
2863 * sessinit is sent but no second negprot
2864 */
2865 struct rfc1002_session_packet *ses_init_buf;
2866 struct smb_hdr *smb_buf;
2867 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2868 GFP_KERNEL);
2869 if (ses_init_buf) {
2870 ses_init_buf->trailer.session_req.called_len = 32;
2871
2872 if (server->server_RFC1001_name &&
2873 server->server_RFC1001_name[0] != 0)
2874 rfc1002mangle(ses_init_buf->trailer.
2875 session_req.called_name,
2876 server->server_RFC1001_name,
2877 RFC1001_NAME_LEN_WITH_NULL);
2878 else
2879 rfc1002mangle(ses_init_buf->trailer.
2880 session_req.called_name,
2881 DEFAULT_CIFS_CALLED_NAME,
2882 RFC1001_NAME_LEN_WITH_NULL);
2883
2884 ses_init_buf->trailer.session_req.calling_len = 32;
2885
2886 /*
2887 * calling name ends in null (byte 16) from old smb
2888 * convention.
2889 */
2890 if (server->workstation_RFC1001_name &&
2891 server->workstation_RFC1001_name[0] != 0)
2892 rfc1002mangle(ses_init_buf->trailer.
2893 session_req.calling_name,
2894 server->workstation_RFC1001_name,
2895 RFC1001_NAME_LEN_WITH_NULL);
2896 else
2897 rfc1002mangle(ses_init_buf->trailer.
2898 session_req.calling_name,
2899 "LINUX_CIFS_CLNT",
2900 RFC1001_NAME_LEN_WITH_NULL);
2901
2902 ses_init_buf->trailer.session_req.scope1 = 0;
2903 ses_init_buf->trailer.session_req.scope2 = 0;
2904 smb_buf = (struct smb_hdr *)ses_init_buf;
2905
2906 /* sizeof RFC1002_SESSION_REQUEST with no scope */
Steve Frenchbe8e3b02011-04-29 05:40:20 +00002907 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002908 rc = smb_send(server, smb_buf, 0x44);
2909 kfree(ses_init_buf);
2910 /*
2911 * RFC1001 layer in at least one server
2912 * requires very short break before negprot
2913 * presumably because not expecting negprot
2914 * to follow so fast. This is a simple
2915 * solution that works without
2916 * complicating the code and causes no
2917 * significant slowing down on mount
2918 * for everyone else
2919 */
2920 usleep_range(1000, 2000);
2921 }
2922 /*
2923 * else the negprot may still work without this
2924 * even though malloc failed
2925 */
2926
2927 return rc;
2928}
2929
2930static int
2931generic_ip_connect(struct TCP_Server_Info *server)
2932{
2933 int rc = 0;
Steve French6da97912011-03-13 18:55:55 +00002934 __be16 sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002935 int slen, sfamily;
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002936 struct socket *socket = server->ssocket;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002937 struct sockaddr *saddr;
2938
2939 saddr = (struct sockaddr *) &server->dstaddr;
2940
2941 if (server->dstaddr.ss_family == AF_INET6) {
2942 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2943 slen = sizeof(struct sockaddr_in6);
2944 sfamily = AF_INET6;
2945 } else {
2946 sport = ((struct sockaddr_in *) saddr)->sin_port;
2947 slen = sizeof(struct sockaddr_in);
2948 sfamily = AF_INET;
2949 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002950
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002951 if (socket == NULL) {
Rob Landleyf1d0c992011-01-22 15:44:05 -06002952 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2953 IPPROTO_TCP, &socket, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002955 cifs_dbg(VFS, "Error %d creating socket\n", rc);
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002956 server->ssocket = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 }
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002959
2960 /* BB other socket options to set KEEPALIVE, NODELAY? */
Joe Perchesf96637b2013-05-04 22:12:25 -05002961 cifs_dbg(FYI, "Socket created\n");
Jeff Laytonbcf4b102008-12-01 18:42:15 -05002962 server->ssocket = socket;
2963 socket->sk->sk_allocation = GFP_NOFS;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002964 if (sfamily == AF_INET6)
2965 cifs_reclassify_socket6(socket);
2966 else
2967 cifs_reclassify_socket4(socket);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 }
2969
Ben Greear3eb9a882010-09-01 17:06:02 -07002970 rc = bind_socket(server);
2971 if (rc < 0)
2972 return rc;
2973
Jeff Laytond5c56052008-12-01 18:42:33 -05002974 /*
2975 * Eventually check for other socket options to change from
2976 * the default. sock_setsockopt not used because it expects
2977 * user space buffer
2978 */
2979 socket->sk->sk_rcvtimeo = 7 * HZ;
Steve Frenchda505c32009-01-19 03:49:35 +00002980 socket->sk->sk_sndtimeo = 5 * HZ;
Steve French6a5fa2362010-01-01 01:28:43 +00002981
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002982 /* make the bufsizes depend on wsize/rsize and max requests */
2983 if (server->noautotune) {
2984 if (socket->sk->sk_sndbuf < (200 * 1024))
2985 socket->sk->sk_sndbuf = 200 * 1024;
2986 if (socket->sk->sk_rcvbuf < (140 * 1024))
2987 socket->sk->sk_rcvbuf = 140 * 1024;
2988 }
2989
Steve French6a5fa2362010-01-01 01:28:43 +00002990 if (server->tcp_nodelay) {
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03002991 int val = 1;
Steve French6a5fa2362010-01-01 01:28:43 +00002992 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2993 (char *)&val, sizeof(val));
2994 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05002995 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
2996 rc);
Steve French6a5fa2362010-01-01 01:28:43 +00002997 }
2998
Joe Perchesf96637b2013-05-04 22:12:25 -05002999 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003000 socket->sk->sk_sndbuf,
3001 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3002
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003003 rc = socket->ops->connect(socket, saddr, slen, 0);
3004 if (rc < 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003005 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
Jeff Laytonee1b3ea2011-06-21 07:18:26 -04003006 sock_release(socket);
3007 server->ssocket = NULL;
3008 return rc;
3009 }
3010
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003011 if (sport == htons(RFC1001_PORT))
3012 rc = ip_rfc1001_connect(server);
Steve French50c2f752007-07-13 00:33:32 +00003013
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 return rc;
3015}
3016
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003017static int
3018ip_connect(struct TCP_Server_Info *server)
3019{
Steve French6da97912011-03-13 18:55:55 +00003020 __be16 *sport;
Pavel Shilovskya9f1b852010-12-13 19:08:35 +03003021 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3022 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3023
3024 if (server->dstaddr.ss_family == AF_INET6)
3025 sport = &addr6->sin6_port;
3026 else
3027 sport = &addr->sin_port;
3028
3029 if (*sport == 0) {
3030 int rc;
3031
3032 /* try with 445 port at first */
3033 *sport = htons(CIFS_PORT);
3034
3035 rc = generic_ip_connect(server);
3036 if (rc >= 0)
3037 return rc;
3038
3039 /* if it failed, try with 139 port */
3040 *sport = htons(RFC1001_PORT);
3041 }
3042
3043 return generic_ip_connect(server);
3044}
3045
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003046void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
Al Viro2c6292a2011-06-17 09:05:48 -04003047 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
Steve French8af18972007-02-14 04:42:51 +00003048{
3049 /* if we are reconnecting then should we check to see if
3050 * any requested capabilities changed locally e.g. via
3051 * remount but we can not do much about it here
3052 * if they have (even if we could detect it by the following)
3053 * Perhaps we could add a backpointer to array of sb from tcon
3054 * or if we change to make all sb to same share the same
3055 * sb as NFS - then we only have one backpointer to sb.
3056 * What if we wanted to mount the server share twice once with
3057 * and once without posixacls or posix paths? */
3058 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Steve French50c2f752007-07-13 00:33:32 +00003059
Steve Frenchc18c8422007-07-18 23:21:09 +00003060 if (vol_info && vol_info->no_linux_ext) {
3061 tcon->fsUnixInfo.Capability = 0;
3062 tcon->unix_ext = 0; /* Unix Extensions disabled */
Joe Perchesf96637b2013-05-04 22:12:25 -05003063 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003064 return;
3065 } else if (vol_info)
3066 tcon->unix_ext = 1; /* Unix Extensions supported */
3067
3068 if (tcon->unix_ext == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003069 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
Steve Frenchc18c8422007-07-18 23:21:09 +00003070 return;
3071 }
Steve French50c2f752007-07-13 00:33:32 +00003072
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003073 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
Steve French8af18972007-02-14 04:42:51 +00003074 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
Joe Perchesf96637b2013-05-04 22:12:25 -05003075 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
Steve French8af18972007-02-14 04:42:51 +00003076 /* check for reconnect case in which we do not
3077 want to change the mount behavior if we can avoid it */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003078 if (vol_info == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003079 /* turn off POSIX ACL and PATHNAMES if not set
Steve French8af18972007-02-14 04:42:51 +00003080 originally at mount time */
3081 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3082 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003083 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3084 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003085 cifs_dbg(VFS, "POSIXPATH support change\n");
Steve French8af18972007-02-14 04:42:51 +00003086 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Igor Mammedov11b6d642008-02-15 19:06:04 +00003087 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003088 cifs_dbg(VFS, "possible reconnect error\n");
3089 cifs_dbg(VFS, "server disabled POSIX path support\n");
Igor Mammedov11b6d642008-02-15 19:06:04 +00003090 }
Steve French8af18972007-02-14 04:42:51 +00003091 }
Steve French50c2f752007-07-13 00:33:32 +00003092
Steve French6848b732011-05-26 18:38:54 +00003093 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003094 cifs_dbg(VFS, "per-share encryption not supported yet\n");
Steve French6848b732011-05-26 18:38:54 +00003095
Steve French8af18972007-02-14 04:42:51 +00003096 cap &= CIFS_UNIX_CAP_MASK;
Steve French75865f8c2007-06-24 18:30:48 +00003097 if (vol_info && vol_info->no_psx_acl)
Steve French8af18972007-02-14 04:42:51 +00003098 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003099 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003100 cifs_dbg(FYI, "negotiated posix acl support\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003101 if (cifs_sb)
3102 cifs_sb->mnt_cifs_flags |=
3103 CIFS_MOUNT_POSIXACL;
Steve French8af18972007-02-14 04:42:51 +00003104 }
3105
Steve French75865f8c2007-06-24 18:30:48 +00003106 if (vol_info && vol_info->posix_paths == 0)
Steve French8af18972007-02-14 04:42:51 +00003107 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
Steve French75865f8c2007-06-24 18:30:48 +00003108 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003109 cifs_dbg(FYI, "negotiate posix pathnames\n");
Al Viro2c6292a2011-06-17 09:05:48 -04003110 if (cifs_sb)
3111 cifs_sb->mnt_cifs_flags |=
Steve French8af18972007-02-14 04:42:51 +00003112 CIFS_MOUNT_POSIX_PATHS;
3113 }
Steve French50c2f752007-07-13 00:33:32 +00003114
Joe Perchesf96637b2013-05-04 22:12:25 -05003115 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
Steve French8af18972007-02-14 04:42:51 +00003116#ifdef CONFIG_CIFS_DEBUG2
Steve French75865f8c2007-06-24 18:30:48 +00003117 if (cap & CIFS_UNIX_FCNTL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003118 cifs_dbg(FYI, "FCNTL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003119 if (cap & CIFS_UNIX_EXTATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003120 cifs_dbg(FYI, "EXTATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003121 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003122 cifs_dbg(FYI, "POSIX path cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003123 if (cap & CIFS_UNIX_XATTR_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003124 cifs_dbg(FYI, "XATTR cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003125 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003126 cifs_dbg(FYI, "POSIX ACL cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003127 if (cap & CIFS_UNIX_LARGE_READ_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003128 cifs_dbg(FYI, "very large read cap\n");
Steve French75865f8c2007-06-24 18:30:48 +00003129 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003130 cifs_dbg(FYI, "very large write cap\n");
Steve French6848b732011-05-26 18:38:54 +00003131 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003132 cifs_dbg(FYI, "transport encryption cap\n");
Steve French6848b732011-05-26 18:38:54 +00003133 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
Joe Perchesf96637b2013-05-04 22:12:25 -05003134 cifs_dbg(FYI, "mandatory transport encryption cap\n");
Steve French8af18972007-02-14 04:42:51 +00003135#endif /* CIFS_DEBUG2 */
3136 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
Steve French442aa312007-09-24 20:25:46 +00003137 if (vol_info == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003138 cifs_dbg(FYI, "resetting capabilities failed\n");
Steve French442aa312007-09-24 20:25:46 +00003139 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05003140 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 +00003141
Steve French8af18972007-02-14 04:42:51 +00003142 }
3143 }
3144}
3145
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003146void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3147 struct cifs_sb_info *cifs_sb)
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003148{
Jeff Layton2de970f2010-10-06 19:51:12 -04003149 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3150
Al Viro2ced6f62011-06-17 09:20:04 -04003151 spin_lock_init(&cifs_sb->tlink_tree_lock);
3152 cifs_sb->tlink_tree = RB_ROOT;
3153
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003154 /*
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003155 * Temporarily set r/wsize for matching superblock. If we end up using
3156 * new sb then client will later negotiate it downward if needed.
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003157 */
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003158 cifs_sb->rsize = pvolume_info->rsize;
Pavel Shilovsky25c7f412011-05-26 23:35:47 +04003159 cifs_sb->wsize = pvolume_info->wsize;
3160
Steve French3b795212008-11-13 19:45:32 +00003161 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3162 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3163 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3164 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
Joe Perchesf96637b2013-05-04 22:12:25 -05003165 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3166 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
Steve French3b795212008-11-13 19:45:32 +00003167
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303168 cifs_sb->actimeo = pvolume_info->actimeo;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003169 cifs_sb->local_nls = pvolume_info->local_nls;
Suresh Jayaraman6d20e842010-12-01 14:42:28 +05303170
Steve French3b795212008-11-13 19:45:32 +00003171 if (pvolume_info->noperm)
3172 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3173 if (pvolume_info->setuids)
3174 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3175 if (pvolume_info->server_ino)
3176 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3177 if (pvolume_info->remap)
3178 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3179 if (pvolume_info->no_xattr)
3180 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3181 if (pvolume_info->sfu_emul)
3182 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3183 if (pvolume_info->nobrl)
3184 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
Steve Frenchbe652442009-02-23 15:21:59 +00003185 if (pvolume_info->nostrictsync)
Steve French4717bed2009-02-24 14:44:19 +00003186 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
Steve French13a6e422008-12-02 17:24:33 +00003187 if (pvolume_info->mand_lock)
3188 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003189 if (pvolume_info->rwpidforward)
3190 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
Steve French3b795212008-11-13 19:45:32 +00003191 if (pvolume_info->cifs_acl)
3192 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003193 if (pvolume_info->backupuid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003194 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003195 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3196 }
3197 if (pvolume_info->backupgid_specified) {
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -05003198 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
Sachin Prabhu3c7c87f2012-04-24 15:28:14 +01003199 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3200 }
Steve French3b795212008-11-13 19:45:32 +00003201 if (pvolume_info->override_uid)
3202 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3203 if (pvolume_info->override_gid)
3204 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3205 if (pvolume_info->dynperm)
3206 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
Suresh Jayaramanfa1df752010-07-05 18:13:36 +05303207 if (pvolume_info->fsc)
3208 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
Jeff Layton0eb8a132010-10-06 19:51:12 -04003209 if (pvolume_info->multiuser)
3210 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3211 CIFS_MOUNT_NO_PERM);
Pavel Shilovskyd39454f2011-01-24 14:16:35 -05003212 if (pvolume_info->strict_io)
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
Steve French3b795212008-11-13 19:45:32 +00003214 if (pvolume_info->direct_io) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003215 cifs_dbg(FYI, "mounting share using direct i/o\n");
Steve French3b795212008-11-13 19:45:32 +00003216 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3217 }
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003218 if (pvolume_info->mfsymlinks) {
3219 if (pvolume_info->sfu_emul) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003220 cifs_dbg(VFS, "mount option mfsymlinks ignored if sfu mount option is used\n");
Stefan Metzmacher736a3322010-07-30 14:56:00 +02003221 } else {
3222 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3223 }
3224 }
Steve French3b795212008-11-13 19:45:32 +00003225
3226 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
Joe Perchesf96637b2013-05-04 22:12:25 -05003227 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
Jeff Laytonb1c8d2b2008-10-22 13:57:07 -04003228}
3229
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003230static void
3231cleanup_volume_info_contents(struct smb_vol *volume_info)
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003232{
Sean Finneyb9468452011-04-11 13:19:32 +00003233 kfree(volume_info->username);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003234 kzfree(volume_info->password);
Jesper Juhl95c75452011-08-27 18:58:34 +02003235 kfree(volume_info->UNC);
Sean Finneyb9468452011-04-11 13:19:32 +00003236 kfree(volume_info->domainname);
3237 kfree(volume_info->iocharset);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003238 kfree(volume_info->prepath);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003239}
3240
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003241void
3242cifs_cleanup_volume_info(struct smb_vol *volume_info)
3243{
3244 if (!volume_info)
3245 return;
3246 cleanup_volume_info_contents(volume_info);
3247 kfree(volume_info);
3248}
3249
3250
Steve French2d6d5892009-04-09 00:36:44 +00003251#ifdef CONFIG_CIFS_DFS_UPCALL
Steve French6d3ea7e2012-11-28 22:34:41 -06003252/*
3253 * cifs_build_path_to_root returns full path to root when we do not have an
3254 * exiting connection (tcon)
3255 */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003256static char *
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003257build_unc_path_to_root(const struct smb_vol *vol,
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003258 const struct cifs_sb_info *cifs_sb)
3259{
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003260 char *full_path, *pos;
Jeff Layton839db3d2012-12-10 06:10:45 -05003261 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003262 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003263
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003264 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003265 if (full_path == NULL)
3266 return ERR_PTR(-ENOMEM);
3267
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003268 strncpy(full_path, vol->UNC, unc_len);
3269 pos = full_path + unc_len;
3270
3271 if (pplen) {
Jeff Layton1fc29ba2013-05-31 10:00:18 -04003272 *pos = CIFS_DIR_SEP(cifs_sb);
3273 strncpy(pos + 1, vol->prepath, pplen);
Jeff Laytonb2a0fa12011-07-06 08:10:36 -04003274 pos += pplen;
3275 }
3276
3277 *pos = '\0'; /* add trailing null */
Steve Frenchf87d39d2011-05-27 03:50:55 +00003278 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
Joe Perchesf96637b2013-05-04 22:12:25 -05003279 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003280 return full_path;
3281}
Sean Finneydd613942011-04-11 13:19:30 +00003282
3283/*
3284 * Perform a dfs referral query for a share and (optionally) prefix
3285 *
Sean Finney046462a2011-04-11 13:19:33 +00003286 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3287 * to a string containing updated options for the submount. Otherwise it
3288 * will be left untouched.
Sean Finneydd613942011-04-11 13:19:30 +00003289 *
3290 * Returns the rc from get_dfs_path to the caller, which can be used to
3291 * determine whether there were referrals.
3292 */
3293static int
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003294expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
Sean Finneydd613942011-04-11 13:19:30 +00003295 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
Sean Finney046462a2011-04-11 13:19:33 +00003296 int check_prefix)
Sean Finneydd613942011-04-11 13:19:30 +00003297{
3298 int rc;
3299 unsigned int num_referrals = 0;
3300 struct dfs_info3_param *referrals = NULL;
3301 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3302
3303 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3304 if (IS_ERR(full_path))
3305 return PTR_ERR(full_path);
3306
3307 /* For DFS paths, skip the first '\' of the UNC */
3308 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3309
Pavel Shilovskyb669f332012-05-27 20:21:53 +04003310 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
Sean Finneydd613942011-04-11 13:19:30 +00003311 &num_referrals, &referrals,
3312 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3313
3314 if (!rc && num_referrals > 0) {
3315 char *fake_devname = NULL;
3316
3317 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3318 full_path + 1, referrals,
3319 &fake_devname);
3320
3321 free_dfs_info_array(referrals, num_referrals);
Sean Finney046462a2011-04-11 13:19:33 +00003322
Sean Finneydd613942011-04-11 13:19:30 +00003323 if (IS_ERR(mdata)) {
3324 rc = PTR_ERR(mdata);
3325 mdata = NULL;
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003326 } else {
3327 cleanup_volume_info_contents(volume_info);
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003328 rc = cifs_setup_volume_info(volume_info, mdata,
3329 fake_devname);
Sean Finneydd613942011-04-11 13:19:30 +00003330 }
Jeff Laytonb9bce2e2011-07-06 08:10:39 -04003331 kfree(fake_devname);
3332 kfree(cifs_sb->mountdata);
Sean Finney046462a2011-04-11 13:19:33 +00003333 cifs_sb->mountdata = mdata;
Sean Finneydd613942011-04-11 13:19:30 +00003334 }
3335 kfree(full_path);
3336 return rc;
3337}
Steve French2d6d5892009-04-09 00:36:44 +00003338#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003339
Jeff Layton04db79b2011-07-06 08:10:38 -04003340static int
3341cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3342 const char *devname)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003343{
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003344 int rc = 0;
Sean Finneydd613942011-04-11 13:19:30 +00003345
Jeff Layton04db79b2011-07-06 08:10:38 -04003346 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3347 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003348
Jeff Layton7586b762008-12-01 18:41:49 -05003349 if (volume_info->nullauth) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003350 cifs_dbg(FYI, "Anonymous login\n");
Jeff Layton04febab2012-01-17 16:09:15 -05003351 kfree(volume_info->username);
3352 volume_info->username = NULL;
Jeff Layton7586b762008-12-01 18:41:49 -05003353 } else if (volume_info->username) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 /* BB fixme parse for domain name here */
Joe Perchesf96637b2013-05-04 22:12:25 -05003355 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003356 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05003357 cifs_dbg(VFS, "No username specified\n");
Steve French50c2f752007-07-13 00:33:32 +00003358 /* In userspace mount helper we can get user name from alternate
3359 locations such as env variables and files on disk */
Jeff Layton04db79b2011-07-06 08:10:38 -04003360 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 }
3362
Linus Torvalds1da177e2005-04-16 15:20:36 -07003363 /* this is needed for ASCII cp to Unicode converts */
Jeff Layton7586b762008-12-01 18:41:49 -05003364 if (volume_info->iocharset == NULL) {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003365 /* load_nls_default cannot return null */
3366 volume_info->local_nls = load_nls_default();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367 } else {
Jeff Laytona5fc4ce2010-04-24 07:57:42 -04003368 volume_info->local_nls = load_nls(volume_info->iocharset);
3369 if (volume_info->local_nls == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003370 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003371 volume_info->iocharset);
Jeff Layton04db79b2011-07-06 08:10:38 -04003372 return -ELIBACC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003373 }
3374 }
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003375
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003376 return rc;
Jeff Layton04db79b2011-07-06 08:10:38 -04003377}
3378
3379struct smb_vol *
3380cifs_get_volume_info(char *mount_data, const char *devname)
3381{
3382 int rc;
3383 struct smb_vol *volume_info;
3384
Jeff Layton6ee95422012-11-26 11:09:57 -05003385 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
Jeff Layton04db79b2011-07-06 08:10:38 -04003386 if (!volume_info)
3387 return ERR_PTR(-ENOMEM);
3388
3389 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3390 if (rc) {
3391 cifs_cleanup_volume_info(volume_info);
3392 volume_info = ERR_PTR(rc);
3393 }
3394
3395 return volume_info;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003396}
3397
3398int
Al Viro2c6292a2011-06-17 09:05:48 -04003399cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003400{
Jeff Layton1daaae82012-03-21 06:30:40 -04003401 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003402 unsigned int xid;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003403 struct cifs_ses *ses;
Steve French96daf2b2011-05-27 04:34:02 +00003404 struct cifs_tcon *tcon;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003405 struct TCP_Server_Info *server;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003406 char *full_path;
3407 struct tcon_link *tlink;
3408#ifdef CONFIG_CIFS_DFS_UPCALL
3409 int referral_walks_count = 0;
Jeff Layton20547492011-07-09 12:21:07 -04003410#endif
Al Virodd854462011-06-17 08:24:42 -04003411
3412 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3413 if (rc)
3414 return rc;
3415
Jeff Layton20547492011-07-09 12:21:07 -04003416#ifdef CONFIG_CIFS_DFS_UPCALL
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003417try_mount_again:
3418 /* cleanup activities if we're chasing a referral */
3419 if (referral_walks_count) {
3420 if (tcon)
3421 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003422 else if (ses)
3423 cifs_put_smb_ses(ses);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003424
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003425 free_xid(xid);
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003426 }
3427#endif
Jeff Layton1daaae82012-03-21 06:30:40 -04003428 rc = 0;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003429 tcon = NULL;
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003430 ses = NULL;
3431 server = NULL;
Pavel Shilovsky724d9f12011-05-05 09:55:12 +00003432 full_path = NULL;
3433 tlink = NULL;
3434
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003435 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003436
Jeff Layton63c038c2008-12-01 18:41:46 -05003437 /* get a reference to a tcp session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003438 server = cifs_get_tcp_session(volume_info);
3439 if (IS_ERR(server)) {
3440 rc = PTR_ERR(server);
Al Virodd854462011-06-17 08:24:42 -04003441 bdi_destroy(&cifs_sb->bdi);
Jeff Layton63c038c2008-12-01 18:41:46 -05003442 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 }
3444
Jeff Layton36988c72010-04-24 07:57:43 -04003445 /* get a reference to a SMB session */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003446 ses = cifs_get_smb_ses(server, volume_info);
3447 if (IS_ERR(ses)) {
3448 rc = PTR_ERR(ses);
3449 ses = NULL;
Jeff Layton36988c72010-04-24 07:57:43 -04003450 goto mount_fail_check;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 }
Steve French50c2f752007-07-13 00:33:32 +00003452
Jeff Laytond00c28d2010-04-24 07:57:44 -04003453 /* search for existing tcon to this server share */
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003454 tcon = cifs_get_tcon(ses, volume_info);
Jeff Laytond00c28d2010-04-24 07:57:44 -04003455 if (IS_ERR(tcon)) {
3456 rc = PTR_ERR(tcon);
3457 tcon = NULL;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003458 goto remote_path_check;
Jeff Laytond00c28d2010-04-24 07:57:44 -04003459 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003460
Steve French6848b732011-05-26 18:38:54 +00003461 /* tell server which Unix caps we support */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003462 if (cap_unix(tcon->ses)) {
Steve French6848b732011-05-26 18:38:54 +00003463 /* reset of caps checks mount to see if unix extensions
3464 disabled for just this mount */
Al Viro2c6292a2011-06-17 09:05:48 -04003465 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
Steve French6848b732011-05-26 18:38:54 +00003466 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3467 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3468 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3469 rc = -EACCES;
3470 goto mount_fail_check;
3471 }
3472 } else
3473 tcon->unix_ext = 0; /* server does not support them */
3474
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003475 /* do not care if a following call succeed - informational */
3476 if (!tcon->ipc && server->ops->qfs_tcon)
3477 server->ops->qfs_tcon(xid, tcon);
Steve Frenchd82c2df2008-11-15 00:07:26 +00003478
Pavel Shilovsky24985c52012-09-18 16:20:28 -07003479 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3480 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
Jeff Laytonf7910cb2011-05-19 16:22:58 -04003481
Jeff Layton66bfaad2011-10-19 15:30:35 -04003482 /* tune readahead according to rsize */
Jeff Layton8f714652012-05-01 17:41:49 -04003483 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
Jeff Layton03ceace2010-12-06 21:07:33 -05003484
Igor Mammedove4cce942009-02-10 14:10:26 +03003485remote_path_check:
3486#ifdef CONFIG_CIFS_DFS_UPCALL
3487 /*
3488 * Perform an unconditional check for whether there are DFS
3489 * referrals for this path without prefix, to provide support
3490 * for DFS referrals from w2k8 servers which don't seem to respond
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003491 * with PATH_NOT_COVERED to requests that include the prefix.
3492 * Chase the referral if found, otherwise continue normally.
Steve Frenchd036f502009-04-03 03:12:08 +00003493 */
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003494 if (referral_walks_count == 0) {
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003495 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3496 false);
Steve Frencheeac8042006-01-13 21:34:58 -08003497 if (!refrc) {
Steve French4523cc32007-04-30 20:13:06 +00003498 referral_walks_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 goto try_mount_again;
3500 }
3501 }
3502#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003503
Steve Frenchf87d39d2011-05-27 03:50:55 +00003504 /* check if a whole path is not remote */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 if (!rc && tcon) {
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003506 if (!server->ops->is_path_accessible) {
3507 rc = -ENOSYS;
3508 goto mount_fail_check;
3509 }
Steve French6d3ea7e2012-11-28 22:34:41 -06003510 /*
3511 * cifs_build_path_to_root works only when we have a valid tcon
3512 */
3513 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 if (full_path == NULL) {
3515 rc = -ENOMEM;
3516 goto mount_fail_check;
3517 }
Pavel Shilovsky68889f22012-05-25 14:40:22 +04003518 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3519 full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 if (rc != 0 && rc != -EREMOTE) {
3521 kfree(full_path);
3522 goto mount_fail_check;
3523 }
3524 kfree(full_path);
3525 }
3526
3527 /* get referral if needed */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003528 if (rc == -EREMOTE) {
3529#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003530 if (referral_walks_count > MAX_NESTED_LINKS) {
3531 /*
3532 * BB: when we implement proper loop detection,
3533 * we will remove this check. But now we need it
3534 * to prevent an indefinite loop if 'DFS tree' is
3535 * misconfigured (i.e. has loops).
3536 */
3537 rc = -ELOOP;
3538 goto mount_fail_check;
3539 }
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003540
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003541 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
Jeff Layton7b91e262009-07-23 15:22:30 -04003542
Sean Finneydd613942011-04-11 13:19:30 +00003543 if (!rc) {
Igor Mammedov5c2503a2009-04-21 19:31:05 +04003544 referral_walks_count++;
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003545 goto try_mount_again;
3546 }
Sean Finneydd613942011-04-11 13:19:30 +00003547 goto mount_fail_check;
Steve Frenchd036f502009-04-03 03:12:08 +00003548#else /* No DFS support, return error on mount */
3549 rc = -EOPNOTSUPP;
3550#endif
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003551 }
3552
Jeff Layton9d002df2010-10-06 19:51:11 -04003553 if (rc)
3554 goto mount_fail_check;
3555
3556 /* now, hang the tcon off of the superblock */
3557 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3558 if (tlink == NULL) {
3559 rc = -ENOMEM;
3560 goto mount_fail_check;
3561 }
3562
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003563 tlink->tl_uid = ses->linux_uid;
Jeff Layton9d002df2010-10-06 19:51:11 -04003564 tlink->tl_tcon = tcon;
3565 tlink->tl_time = jiffies;
3566 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3567 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3568
Jeff Layton413e6612010-10-28 13:33:38 -04003569 cifs_sb->master_tlink = tlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04003570 spin_lock(&cifs_sb->tlink_tree_lock);
3571 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3572 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton413e6612010-10-28 13:33:38 -04003573
Jeff Laytonda472fc2012-03-23 14:40:53 -04003574 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04003575 TLINK_IDLE_EXPIRE);
3576
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003577mount_fail_check:
3578 /* on error free sesinfo and tcon struct if needed */
3579 if (rc) {
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003580 /* If find_unc succeeded then rc == 0 so we can not end */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003581 /* up accidentally freeing someone elses tcon struct */
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003582 if (tcon)
3583 cifs_put_tcon(tcon);
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003584 else if (ses)
3585 cifs_put_smb_ses(ses);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003586 else
Pavel Shilovskyaf4281d2012-05-27 20:48:35 +04003587 cifs_put_tcp_session(server);
Al Virodd854462011-06-17 08:24:42 -04003588 bdi_destroy(&cifs_sb->bdi);
Igor Mammedov1bfe73c2009-04-01 17:54:42 +04003589 }
3590
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003592 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 return rc;
3594}
3595
Jeff Layton8d1bca32011-06-11 21:17:10 -04003596/*
3597 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3598 * pointer may be NULL.
3599 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003600int
Pavel Shilovsky2e6e02a2012-05-25 11:11:39 +04003601CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
Steve French96daf2b2011-05-27 04:34:02 +00003602 const char *tree, struct cifs_tcon *tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 const struct nls_table *nls_codepage)
3604{
3605 struct smb_hdr *smb_buffer;
3606 struct smb_hdr *smb_buffer_response;
3607 TCONX_REQ *pSMB;
3608 TCONX_RSP *pSMBr;
3609 unsigned char *bcc_ptr;
3610 int rc = 0;
Jeff Layton690c5222011-01-20 13:36:51 -05003611 int length;
3612 __u16 bytes_left, count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003613
3614 if (ses == NULL)
3615 return -EIO;
3616
3617 smb_buffer = cifs_buf_get();
Steve Frenchca43e3b2009-09-01 17:20:50 +00003618 if (smb_buffer == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 return -ENOMEM;
Steve Frenchca43e3b2009-09-01 17:20:50 +00003620
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 smb_buffer_response = smb_buffer;
3622
3623 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3624 NULL /*no tid */ , 4 /*wct */ );
Steve French1982c342005-08-17 12:38:22 -07003625
Pavel Shilovsky88257362012-05-23 14:01:59 +04003626 smb_buffer->Mid = get_next_mid(ses->server);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627 smb_buffer->Uid = ses->Suid;
3628 pSMB = (TCONX_REQ *) smb_buffer;
3629 pSMBr = (TCONX_RSP *) smb_buffer_response;
3630
3631 pSMB->AndXCommand = 0xFF;
3632 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633 bcc_ptr = &pSMB->Password[0];
Jeff Layton8d1bca32011-06-11 21:17:10 -04003634 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
Steve Frencheeac8042006-01-13 21:34:58 -08003635 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
Steve French7c7b25b2006-06-01 19:20:10 +00003636 *bcc_ptr = 0; /* password is null byte */
Steve Frencheeac8042006-01-13 21:34:58 -08003637 bcc_ptr++; /* skip password */
Steve French7c7b25b2006-06-01 19:20:10 +00003638 /* already aligned so no need to do it below */
Steve Frencheeac8042006-01-13 21:34:58 -08003639 } else {
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003640 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
Steve Frencheeac8042006-01-13 21:34:58 -08003641 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3642 specified as required (when that support is added to
3643 the vfs in the future) as only NTLM or the much
Steve French7c7b25b2006-06-01 19:20:10 +00003644 weaker LANMAN (which we do not send by default) is accepted
Steve Frencheeac8042006-01-13 21:34:58 -08003645 by Samba (not sure whether other servers allow
3646 NTLMv2 password here) */
Steve French7c7b25b2006-06-01 19:20:10 +00003647#ifdef CONFIG_CIFS_WEAK_PW_HASH
Jeff Layton04912d62010-04-24 07:57:45 -04003648 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
Jeff Layton3f618222013-06-12 19:52:14 -05003649 (ses->sectype == LANMAN))
Shirish Pargaonkard3ba50b2010-10-27 15:20:36 -05003650 calc_lanman_hash(tcon->password, ses->server->cryptkey,
Steve French96daf2b2011-05-27 04:34:02 +00003651 ses->server->sec_mode &
Jeff Layton4e53a3f2008-12-05 20:41:21 -05003652 SECMODE_PW_ENCRYPT ? true : false,
3653 bcc_ptr);
Steve French7c7b25b2006-06-01 19:20:10 +00003654 else
3655#endif /* CIFS_WEAK_PW_HASH */
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -06003656 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
Shirish Pargaonkar9ef59922011-10-20 13:21:59 -05003657 bcc_ptr, nls_codepage);
Steve Frencheeac8042006-01-13 21:34:58 -08003658
Shirish Pargaonkar540b2e32011-01-18 22:33:54 -06003659 bcc_ptr += CIFS_AUTH_RESP_SIZE;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003660 if (ses->capabilities & CAP_UNICODE) {
Steve French7c7b25b2006-06-01 19:20:10 +00003661 /* must align unicode strings */
3662 *bcc_ptr = 0; /* null byte password */
3663 bcc_ptr++;
3664 }
Steve Frencheeac8042006-01-13 21:34:58 -08003665 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666
Jeff Layton38d77c52013-05-26 07:01:00 -04003667 if (ses->server->sign)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3669
3670 if (ses->capabilities & CAP_STATUS32) {
3671 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3672 }
3673 if (ses->capabilities & CAP_DFS) {
3674 smb_buffer->Flags2 |= SMBFLG2_DFS;
3675 }
3676 if (ses->capabilities & CAP_UNICODE) {
3677 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3678 length =
Steve Frenchacbbb762012-01-18 22:32:33 -06003679 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
Steve French50c2f752007-07-13 00:33:32 +00003680 6 /* max utf8 char length in bytes */ *
Steve Frencha878fb22006-05-30 18:04:19 +00003681 (/* server len*/ + 256 /* share len */), nls_codepage);
3682 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003683 bcc_ptr += 2; /* skip trailing null */
3684 } else { /* ASCII */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003685 strcpy(bcc_ptr, tree);
3686 bcc_ptr += strlen(tree) + 1;
3687 }
3688 strcpy(bcc_ptr, "?????");
3689 bcc_ptr += strlen("?????");
3690 bcc_ptr += 1;
3691 count = bcc_ptr - &pSMB->Password[0];
Steve Frenchbe8e3b02011-04-29 05:40:20 +00003692 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3693 pSMB->hdr.smb_buf_length) + count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003694 pSMB->ByteCount = cpu_to_le16(count);
3695
Steve French133672e2007-11-13 22:41:37 +00003696 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
Jeff Layton77499812011-01-11 07:24:23 -05003697 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003698
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699 /* above now done in SendReceive */
3700 if ((rc == 0) && (tcon != NULL)) {
Steve French0e0d2cf2009-05-01 05:27:32 +00003701 bool is_unicode;
3702
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703 tcon->tidStatus = CifsGood;
Steve French3b795212008-11-13 19:45:32 +00003704 tcon->need_reconnect = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705 tcon->tid = smb_buffer_response->Tid;
3706 bcc_ptr = pByteArea(smb_buffer_response);
Jeff Layton690c5222011-01-20 13:36:51 -05003707 bytes_left = get_bcc(smb_buffer_response);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003708 length = strnlen(bcc_ptr, bytes_left - 2);
Steve French0e0d2cf2009-05-01 05:27:32 +00003709 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3710 is_unicode = true;
3711 else
3712 is_unicode = false;
3713
Jeff Laytoncc20c032009-04-30 07:16:21 -04003714
Steve French50c2f752007-07-13 00:33:32 +00003715 /* skip service field (NB: this field is always ASCII) */
Steve French7f8ed422007-09-28 22:28:55 +00003716 if (length == 3) {
3717 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3718 (bcc_ptr[2] == 'C')) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003719 cifs_dbg(FYI, "IPC connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003720 tcon->ipc = 1;
3721 }
3722 } else if (length == 2) {
3723 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3724 /* the most common case */
Joe Perchesf96637b2013-05-04 22:12:25 -05003725 cifs_dbg(FYI, "disk share connection\n");
Steve French7f8ed422007-09-28 22:28:55 +00003726 }
3727 }
Steve French50c2f752007-07-13 00:33:32 +00003728 bcc_ptr += length + 1;
Jeff Laytoncc20c032009-04-30 07:16:21 -04003729 bytes_left -= (length + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003731
3732 /* mostly informational -- no need to fail on error here */
Jeff Layton90a98b22009-07-20 13:40:52 -04003733 kfree(tcon->nativeFileSystem);
Steve Frenchacbbb762012-01-18 22:32:33 -06003734 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
Steve French0e0d2cf2009-05-01 05:27:32 +00003735 bytes_left, is_unicode,
Jeff Laytoncc20c032009-04-30 07:16:21 -04003736 nls_codepage);
3737
Joe Perchesf96637b2013-05-04 22:12:25 -05003738 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
Jeff Laytoncc20c032009-04-30 07:16:21 -04003739
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003740 if ((smb_buffer_response->WordCount == 3) ||
Steve French1a4e15a2006-10-12 21:33:51 +00003741 (smb_buffer_response->WordCount == 7))
3742 /* field is in same location */
Steve French39798772006-05-31 22:40:51 +00003743 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3744 else
3745 tcon->Flags = 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003746 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003747 } else if ((rc == 0) && tcon == NULL) {
Steve French50c2f752007-07-13 00:33:32 +00003748 /* all we need to save for IPC$ connection */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003749 ses->ipc_tid = smb_buffer_response->Tid;
3750 }
3751
Mariusz Kozlowskia8a11d32007-10-03 16:41:24 +00003752 cifs_buf_release(smb_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003753 return rc;
3754}
3755
Al Viro2a9b9952011-06-17 09:27:16 -04003756void
3757cifs_umount(struct cifs_sb_info *cifs_sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003758{
Jeff Laytonb647c352010-10-28 11:16:44 -04003759 struct rb_root *root = &cifs_sb->tlink_tree;
3760 struct rb_node *node;
3761 struct tcon_link *tlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003762
Jeff Layton2de970f2010-10-06 19:51:12 -04003763 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3764
Jeff Laytonb647c352010-10-28 11:16:44 -04003765 spin_lock(&cifs_sb->tlink_tree_lock);
3766 while ((node = rb_first(root))) {
3767 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3768 cifs_get_tlink(tlink);
3769 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3770 rb_erase(node, root);
Steve French50c2f752007-07-13 00:33:32 +00003771
Jeff Laytonb647c352010-10-28 11:16:44 -04003772 spin_unlock(&cifs_sb->tlink_tree_lock);
3773 cifs_put_tlink(tlink);
3774 spin_lock(&cifs_sb->tlink_tree_lock);
3775 }
3776 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003777
Al Virodd854462011-06-17 08:24:42 -04003778 bdi_destroy(&cifs_sb->bdi);
Al Virod757d712011-06-17 09:42:43 -04003779 kfree(cifs_sb->mountdata);
3780 unload_nls(cifs_sb->local_nls);
3781 kfree(cifs_sb);
Steve French50c2f752007-07-13 00:33:32 +00003782}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003784int
3785cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003786{
3787 int rc = 0;
Jeff Layton198b5682010-04-24 07:57:48 -04003788 struct TCP_Server_Info *server = ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003789
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003790 if (!server->ops->need_neg || !server->ops->negotiate)
3791 return -ENOSYS;
3792
Jeff Layton198b5682010-04-24 07:57:48 -04003793 /* only send once per connect */
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003794 if (!server->ops->need_neg(server))
Jeff Layton198b5682010-04-24 07:57:48 -04003795 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003796
Pavel Shilovsky45275782012-05-17 17:53:29 +04003797 set_credits(server, 1);
Pavel Shilovsky286170a2012-05-25 10:43:58 +04003798
3799 rc = server->ops->negotiate(xid, ses);
Jeff Layton198b5682010-04-24 07:57:48 -04003800 if (rc == 0) {
3801 spin_lock(&GlobalMid_Lock);
Jeff Layton7fdbaa12011-06-10 16:14:57 -04003802 if (server->tcpStatus == CifsNeedNegotiate)
Jeff Layton198b5682010-04-24 07:57:48 -04003803 server->tcpStatus = CifsGood;
3804 else
3805 rc = -EHOSTDOWN;
3806 spin_unlock(&GlobalMid_Lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807 }
Steve French26b994f2008-08-06 05:11:33 +00003808
Jeff Layton198b5682010-04-24 07:57:48 -04003809 return rc;
3810}
Steve French26b994f2008-08-06 05:11:33 +00003811
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003812int
3813cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3814 struct nls_table *nls_info)
Jeff Layton198b5682010-04-24 07:57:48 -04003815{
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003816 int rc = -ENOSYS;
Jeff Layton198b5682010-04-24 07:57:48 -04003817 struct TCP_Server_Info *server = ses->server;
3818
Jeff Layton198b5682010-04-24 07:57:48 -04003819 ses->capabilities = server->capabilities;
Steve French26b994f2008-08-06 05:11:33 +00003820 if (linuxExtEnabled == 0)
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003821 ses->capabilities &= (~server->vals->cap_unix);
Steve French20418ac2009-04-30 16:13:32 +00003822
Joe Perchesf96637b2013-05-04 22:12:25 -05003823 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
Steve French96daf2b2011-05-27 04:34:02 +00003824 server->sec_mode, server->capabilities, server->timeAdj);
Jeff Laytoncb7691b2008-08-18 15:41:05 -04003825
Pavel Shilovsky58c45c52012-05-25 10:54:49 +04003826 if (server->ops->sess_setup)
3827 rc = server->ops->sess_setup(xid, ses, nls_info);
3828
Steve French26b994f2008-08-06 05:11:33 +00003829 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003830 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
Steve French26b994f2008-08-06 05:11:33 +00003831 } else {
Dan Carpenterb13ce4b2013-04-10 14:43:00 +03003832 mutex_lock(&server->srv_mutex);
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003833 if (!server->session_estab) {
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003834 server->session_key.response = ses->auth_key.response;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003835 server->session_key.len = ses->auth_key.len;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003836 server->sequence_number = 0x2;
3837 server->session_estab = true;
3838 ses->auth_key.response = NULL;
Shirish Pargaonkar5d0d2882010-10-13 18:15:00 -05003839 }
3840 mutex_unlock(&server->srv_mutex);
3841
Joe Perchesf96637b2013-05-04 22:12:25 -05003842 cifs_dbg(FYI, "CIFS Session Established successfully\n");
Steve French20418ac2009-04-30 16:13:32 +00003843 spin_lock(&GlobalMid_Lock);
Jeff Layton198b5682010-04-24 07:57:48 -04003844 ses->status = CifsGood;
3845 ses->need_reconnect = false;
Steve French20418ac2009-04-30 16:13:32 +00003846 spin_unlock(&GlobalMid_Lock);
Steve French26b994f2008-08-06 05:11:33 +00003847 }
3848
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003849 kfree(ses->auth_key.response);
3850 ses->auth_key.response = NULL;
3851 ses->auth_key.len = 0;
Shirish Pargaonkard3686d52010-10-28 09:53:07 -05003852 kfree(ses->ntlmssp);
3853 ses->ntlmssp = NULL;
Shirish Pargaonkar21e73392010-10-21 06:42:55 -05003854
Linus Torvalds1da177e2005-04-16 15:20:36 -07003855 return rc;
3856}
3857
Jeff Layton8a8798a2012-01-17 16:09:15 -05003858static int
3859cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3860{
Jeff Layton3f618222013-06-12 19:52:14 -05003861 vol->sectype = ses->sectype;
3862
3863 /* krb5 is special, since we don't need username or pw */
3864 if (vol->sectype == Kerberos)
Jeff Layton8a8798a2012-01-17 16:09:15 -05003865 return 0;
Jeff Layton8a8798a2012-01-17 16:09:15 -05003866
3867 return cifs_set_cifscreds(vol, ses);
3868}
3869
Steve French96daf2b2011-05-27 04:34:02 +00003870static struct cifs_tcon *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003871cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
Jeff Layton9d002df2010-10-06 19:51:11 -04003872{
Jeff Layton8a8798a2012-01-17 16:09:15 -05003873 int rc;
Steve French96daf2b2011-05-27 04:34:02 +00003874 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3875 struct cifs_ses *ses;
3876 struct cifs_tcon *tcon = NULL;
Jeff Layton9d002df2010-10-06 19:51:11 -04003877 struct smb_vol *vol_info;
Jeff Layton9d002df2010-10-06 19:51:11 -04003878
3879 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
Dan Carpenter803ab972012-01-24 11:39:22 +03003880 if (vol_info == NULL)
3881 return ERR_PTR(-ENOMEM);
Jeff Layton9d002df2010-10-06 19:51:11 -04003882
Jeff Layton9d002df2010-10-06 19:51:11 -04003883 vol_info->local_nls = cifs_sb->local_nls;
3884 vol_info->linux_uid = fsuid;
3885 vol_info->cred_uid = fsuid;
3886 vol_info->UNC = master_tcon->treeName;
3887 vol_info->retry = master_tcon->retry;
3888 vol_info->nocase = master_tcon->nocase;
3889 vol_info->local_lease = master_tcon->local_lease;
3890 vol_info->no_linux_ext = !master_tcon->unix_ext;
Jeff Layton28e11bd2013-05-26 07:01:00 -04003891 vol_info->sectype = master_tcon->ses->sectype;
3892 vol_info->sign = master_tcon->ses->sign;
Jeff Layton9d002df2010-10-06 19:51:11 -04003893
Jeff Layton8a8798a2012-01-17 16:09:15 -05003894 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3895 if (rc) {
3896 tcon = ERR_PTR(rc);
3897 goto out;
3898 }
Jeff Layton9d002df2010-10-06 19:51:11 -04003899
3900 /* get a reference for the same TCP session */
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303901 spin_lock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003902 ++master_tcon->ses->server->srv_count;
Suresh Jayaraman3f9bcca2010-10-18 23:29:37 +05303903 spin_unlock(&cifs_tcp_ses_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04003904
3905 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3906 if (IS_ERR(ses)) {
Steve French96daf2b2011-05-27 04:34:02 +00003907 tcon = (struct cifs_tcon *)ses;
Jeff Layton9d002df2010-10-06 19:51:11 -04003908 cifs_put_tcp_session(master_tcon->ses->server);
3909 goto out;
3910 }
3911
3912 tcon = cifs_get_tcon(ses, vol_info);
3913 if (IS_ERR(tcon)) {
3914 cifs_put_smb_ses(ses);
3915 goto out;
3916 }
3917
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003918 if (cap_unix(ses))
Jeff Layton9d002df2010-10-06 19:51:11 -04003919 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3920out:
Jeff Layton8a8798a2012-01-17 16:09:15 -05003921 kfree(vol_info->username);
3922 kfree(vol_info->password);
Jeff Layton9d002df2010-10-06 19:51:11 -04003923 kfree(vol_info);
3924
3925 return tcon;
3926}
3927
Steve French96daf2b2011-05-27 04:34:02 +00003928struct cifs_tcon *
Jeff Layton9d002df2010-10-06 19:51:11 -04003929cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3930{
3931 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3932}
3933
3934static int
3935cifs_sb_tcon_pending_wait(void *unused)
3936{
3937 schedule();
3938 return signal_pending(current) ? -ERESTARTSYS : 0;
3939}
3940
Jeff Laytonb647c352010-10-28 11:16:44 -04003941/* find and return a tlink with given uid */
3942static struct tcon_link *
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003943tlink_rb_search(struct rb_root *root, kuid_t uid)
Jeff Laytonb647c352010-10-28 11:16:44 -04003944{
3945 struct rb_node *node = root->rb_node;
3946 struct tcon_link *tlink;
3947
3948 while (node) {
3949 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3950
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003951 if (uid_gt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003952 node = node->rb_left;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003953 else if (uid_lt(tlink->tl_uid, uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003954 node = node->rb_right;
3955 else
3956 return tlink;
3957 }
3958 return NULL;
3959}
3960
3961/* insert a tcon_link into the tree */
3962static void
3963tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3964{
3965 struct rb_node **new = &(root->rb_node), *parent = NULL;
3966 struct tcon_link *tlink;
3967
3968 while (*new) {
3969 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3970 parent = *new;
3971
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08003972 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
Jeff Laytonb647c352010-10-28 11:16:44 -04003973 new = &((*new)->rb_left);
3974 else
3975 new = &((*new)->rb_right);
3976 }
3977
3978 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3979 rb_insert_color(&new_tlink->tl_rbnode, root);
3980}
3981
Jeff Layton9d002df2010-10-06 19:51:11 -04003982/*
3983 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3984 * current task.
3985 *
3986 * If the superblock doesn't refer to a multiuser mount, then just return
3987 * the master tcon for the mount.
3988 *
Suresh Jayaraman6ef933a2010-11-03 10:53:49 +05303989 * First, search the rbtree for an existing tcon for this fsuid. If one
Jeff Layton9d002df2010-10-06 19:51:11 -04003990 * exists, then check to see if it's pending construction. If it is then wait
3991 * for construction to complete. Once it's no longer pending, check to see if
3992 * it failed and either return an error or retry construction, depending on
3993 * the timeout.
3994 *
3995 * If one doesn't exist then insert a new tcon_link struct into the tree and
3996 * try to construct a new one.
3997 */
3998struct tcon_link *
3999cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4000{
4001 int ret;
Eric W. Biederman6d4a0832013-02-06 01:48:56 -08004002 kuid_t fsuid = current_fsuid();
Jeff Layton9d002df2010-10-06 19:51:11 -04004003 struct tcon_link *tlink, *newtlink;
4004
4005 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4006 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4007
4008 spin_lock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004009 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004010 if (tlink)
4011 cifs_get_tlink(tlink);
4012 spin_unlock(&cifs_sb->tlink_tree_lock);
4013
4014 if (tlink == NULL) {
4015 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4016 if (newtlink == NULL)
4017 return ERR_PTR(-ENOMEM);
Jeff Laytonb647c352010-10-28 11:16:44 -04004018 newtlink->tl_uid = fsuid;
Jeff Layton9d002df2010-10-06 19:51:11 -04004019 newtlink->tl_tcon = ERR_PTR(-EACCES);
4020 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4021 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4022 cifs_get_tlink(newtlink);
4023
Jeff Layton9d002df2010-10-06 19:51:11 -04004024 spin_lock(&cifs_sb->tlink_tree_lock);
4025 /* was one inserted after previous search? */
Jeff Laytonb647c352010-10-28 11:16:44 -04004026 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
Jeff Layton9d002df2010-10-06 19:51:11 -04004027 if (tlink) {
4028 cifs_get_tlink(tlink);
4029 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004030 kfree(newtlink);
4031 goto wait_for_construction;
4032 }
Jeff Layton9d002df2010-10-06 19:51:11 -04004033 tlink = newtlink;
Jeff Laytonb647c352010-10-28 11:16:44 -04004034 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4035 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton9d002df2010-10-06 19:51:11 -04004036 } else {
4037wait_for_construction:
4038 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4039 cifs_sb_tcon_pending_wait,
4040 TASK_INTERRUPTIBLE);
4041 if (ret) {
4042 cifs_put_tlink(tlink);
4043 return ERR_PTR(ret);
4044 }
4045
4046 /* if it's good, return it */
4047 if (!IS_ERR(tlink->tl_tcon))
4048 return tlink;
4049
4050 /* return error if we tried this already recently */
4051 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4052 cifs_put_tlink(tlink);
4053 return ERR_PTR(-EACCES);
4054 }
4055
4056 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4057 goto wait_for_construction;
4058 }
4059
4060 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4061 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4062 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4063
4064 if (IS_ERR(tlink->tl_tcon)) {
4065 cifs_put_tlink(tlink);
4066 return ERR_PTR(-EACCES);
4067 }
4068
4069 return tlink;
4070}
Jeff Layton2de970f2010-10-06 19:51:12 -04004071
4072/*
4073 * periodic workqueue job that scans tcon_tree for a superblock and closes
4074 * out tcons.
4075 */
4076static void
4077cifs_prune_tlinks(struct work_struct *work)
4078{
4079 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4080 prune_tlinks.work);
Jeff Laytonb647c352010-10-28 11:16:44 -04004081 struct rb_root *root = &cifs_sb->tlink_tree;
4082 struct rb_node *node = rb_first(root);
4083 struct rb_node *tmp;
4084 struct tcon_link *tlink;
Jeff Layton2de970f2010-10-06 19:51:12 -04004085
Jeff Laytonb647c352010-10-28 11:16:44 -04004086 /*
4087 * Because we drop the spinlock in the loop in order to put the tlink
4088 * it's not guarded against removal of links from the tree. The only
4089 * places that remove entries from the tree are this function and
4090 * umounts. Because this function is non-reentrant and is canceled
4091 * before umount can proceed, this is safe.
4092 */
4093 spin_lock(&cifs_sb->tlink_tree_lock);
4094 node = rb_first(root);
4095 while (node != NULL) {
4096 tmp = node;
4097 node = rb_next(tmp);
4098 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4099
4100 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4101 atomic_read(&tlink->tl_count) != 0 ||
4102 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4103 continue;
4104
4105 cifs_get_tlink(tlink);
4106 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4107 rb_erase(tmp, root);
4108
Jeff Layton2de970f2010-10-06 19:51:12 -04004109 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Laytonb647c352010-10-28 11:16:44 -04004110 cifs_put_tlink(tlink);
4111 spin_lock(&cifs_sb->tlink_tree_lock);
4112 }
4113 spin_unlock(&cifs_sb->tlink_tree_lock);
Jeff Layton2de970f2010-10-06 19:51:12 -04004114
Jeff Laytonda472fc2012-03-23 14:40:53 -04004115 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
Jeff Layton2de970f2010-10-06 19:51:12 -04004116 TLINK_IDLE_EXPIRE);
4117}