]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - fs/cifs/connect.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'asoc-v5.7' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[mirror_ubuntu-hirsute-kernel.git] / fs / cifs / connect.c
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/sched/signal.h>
25 #include <linux/list.h>
26 #include <linux/wait.h>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/ctype.h>
30 #include <linux/utsname.h>
31 #include <linux/mempool.h>
32 #include <linux/delay.h>
33 #include <linux/completion.h>
34 #include <linux/kthread.h>
35 #include <linux/pagevec.h>
36 #include <linux/freezer.h>
37 #include <linux/namei.h>
38 #include <linux/uuid.h>
39 #include <linux/uaccess.h>
40 #include <asm/processor.h>
41 #include <linux/inet.h>
42 #include <linux/module.h>
43 #include <keys/user-type.h>
44 #include <net/ipv6.h>
45 #include <linux/parser.h>
46 #include <linux/bvec.h>
47 #include "cifspdu.h"
48 #include "cifsglob.h"
49 #include "cifsproto.h"
50 #include "cifs_unicode.h"
51 #include "cifs_debug.h"
52 #include "cifs_fs_sb.h"
53 #include "ntlmssp.h"
54 #include "nterr.h"
55 #include "rfc1002pdu.h"
56 #include "fscache.h"
57 #include "smb2proto.h"
58 #include "smbdirect.h"
59 #include "dns_resolve.h"
60 #include "cifsfs.h"
61 #ifdef CONFIG_CIFS_DFS_UPCALL
62 #include "dfs_cache.h"
63 #endif
64
65 extern mempool_t *cifs_req_poolp;
66 extern bool disable_legacy_dialects;
67
68 /* FIXME: should these be tunable? */
69 #define TLINK_ERROR_EXPIRE (1 * HZ)
70 #define TLINK_IDLE_EXPIRE (600 * HZ)
71
72 enum {
73 /* Mount options that take no arguments */
74 Opt_user_xattr, Opt_nouser_xattr,
75 Opt_forceuid, Opt_noforceuid,
76 Opt_forcegid, Opt_noforcegid,
77 Opt_noblocksend, Opt_noautotune, Opt_nolease,
78 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
79 Opt_mapposix, Opt_nomapposix,
80 Opt_mapchars, Opt_nomapchars, Opt_sfu,
81 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
82 Opt_noposixpaths, Opt_nounix, Opt_unix,
83 Opt_nocase,
84 Opt_brl, Opt_nobrl,
85 Opt_handlecache, Opt_nohandlecache,
86 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
87 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
88 Opt_nohard, Opt_nosoft,
89 Opt_nointr, Opt_intr,
90 Opt_nostrictsync, Opt_strictsync,
91 Opt_serverino, Opt_noserverino,
92 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
93 Opt_acl, Opt_noacl, Opt_locallease,
94 Opt_sign, Opt_ignore_signature, Opt_seal, Opt_noac,
95 Opt_fsc, Opt_mfsymlinks,
96 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
97 Opt_persistent, Opt_nopersistent,
98 Opt_resilient, Opt_noresilient,
99 Opt_domainauto, Opt_rdma, Opt_modesid, Opt_rootfs,
100 Opt_multichannel, Opt_nomultichannel,
101 Opt_compress,
102
103 /* Mount options which take numeric value */
104 Opt_backupuid, Opt_backupgid, Opt_uid,
105 Opt_cruid, Opt_gid, Opt_file_mode,
106 Opt_dirmode, Opt_port,
107 Opt_min_enc_offload,
108 Opt_blocksize, Opt_rsize, Opt_wsize, Opt_actimeo,
109 Opt_echo_interval, Opt_max_credits, Opt_handletimeout,
110 Opt_snapshot, Opt_max_channels,
111
112 /* Mount options which take string value */
113 Opt_user, Opt_pass, Opt_ip,
114 Opt_domain, Opt_srcaddr, Opt_iocharset,
115 Opt_netbiosname, Opt_servern,
116 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
117
118 /* Mount options to be ignored */
119 Opt_ignore,
120
121 /* Options which could be blank */
122 Opt_blank_pass,
123 Opt_blank_user,
124 Opt_blank_ip,
125
126 Opt_err
127 };
128
129 static const match_table_t cifs_mount_option_tokens = {
130
131 { Opt_user_xattr, "user_xattr" },
132 { Opt_nouser_xattr, "nouser_xattr" },
133 { Opt_forceuid, "forceuid" },
134 { Opt_noforceuid, "noforceuid" },
135 { Opt_forcegid, "forcegid" },
136 { Opt_noforcegid, "noforcegid" },
137 { Opt_noblocksend, "noblocksend" },
138 { Opt_noautotune, "noautotune" },
139 { Opt_nolease, "nolease" },
140 { Opt_hard, "hard" },
141 { Opt_soft, "soft" },
142 { Opt_perm, "perm" },
143 { Opt_noperm, "noperm" },
144 { Opt_mapchars, "mapchars" }, /* SFU style */
145 { Opt_nomapchars, "nomapchars" },
146 { Opt_mapposix, "mapposix" }, /* SFM style */
147 { Opt_nomapposix, "nomapposix" },
148 { Opt_sfu, "sfu" },
149 { Opt_nosfu, "nosfu" },
150 { Opt_nodfs, "nodfs" },
151 { Opt_posixpaths, "posixpaths" },
152 { Opt_noposixpaths, "noposixpaths" },
153 { Opt_nounix, "nounix" },
154 { Opt_nounix, "nolinux" },
155 { Opt_nounix, "noposix" },
156 { Opt_unix, "unix" },
157 { Opt_unix, "linux" },
158 { Opt_unix, "posix" },
159 { Opt_nocase, "nocase" },
160 { Opt_nocase, "ignorecase" },
161 { Opt_brl, "brl" },
162 { Opt_nobrl, "nobrl" },
163 { Opt_handlecache, "handlecache" },
164 { Opt_nohandlecache, "nohandlecache" },
165 { Opt_nobrl, "nolock" },
166 { Opt_forcemandatorylock, "forcemandatorylock" },
167 { Opt_forcemandatorylock, "forcemand" },
168 { Opt_setuids, "setuids" },
169 { Opt_nosetuids, "nosetuids" },
170 { Opt_setuidfromacl, "idsfromsid" },
171 { Opt_dynperm, "dynperm" },
172 { Opt_nodynperm, "nodynperm" },
173 { Opt_nohard, "nohard" },
174 { Opt_nosoft, "nosoft" },
175 { Opt_nointr, "nointr" },
176 { Opt_intr, "intr" },
177 { Opt_nostrictsync, "nostrictsync" },
178 { Opt_strictsync, "strictsync" },
179 { Opt_serverino, "serverino" },
180 { Opt_noserverino, "noserverino" },
181 { Opt_rwpidforward, "rwpidforward" },
182 { Opt_modesid, "modefromsid" },
183 { Opt_cifsacl, "cifsacl" },
184 { Opt_nocifsacl, "nocifsacl" },
185 { Opt_acl, "acl" },
186 { Opt_noacl, "noacl" },
187 { Opt_locallease, "locallease" },
188 { Opt_sign, "sign" },
189 { Opt_ignore_signature, "signloosely" },
190 { Opt_seal, "seal" },
191 { Opt_noac, "noac" },
192 { Opt_fsc, "fsc" },
193 { Opt_mfsymlinks, "mfsymlinks" },
194 { Opt_multiuser, "multiuser" },
195 { Opt_sloppy, "sloppy" },
196 { Opt_nosharesock, "nosharesock" },
197 { Opt_persistent, "persistenthandles"},
198 { Opt_nopersistent, "nopersistenthandles"},
199 { Opt_resilient, "resilienthandles"},
200 { Opt_noresilient, "noresilienthandles"},
201 { Opt_domainauto, "domainauto"},
202 { Opt_rdma, "rdma"},
203 { Opt_multichannel, "multichannel" },
204 { Opt_nomultichannel, "nomultichannel" },
205
206 { Opt_backupuid, "backupuid=%s" },
207 { Opt_backupgid, "backupgid=%s" },
208 { Opt_uid, "uid=%s" },
209 { Opt_cruid, "cruid=%s" },
210 { Opt_gid, "gid=%s" },
211 { Opt_file_mode, "file_mode=%s" },
212 { Opt_dirmode, "dirmode=%s" },
213 { Opt_dirmode, "dir_mode=%s" },
214 { Opt_port, "port=%s" },
215 { Opt_min_enc_offload, "esize=%s" },
216 { Opt_blocksize, "bsize=%s" },
217 { Opt_rsize, "rsize=%s" },
218 { Opt_wsize, "wsize=%s" },
219 { Opt_actimeo, "actimeo=%s" },
220 { Opt_handletimeout, "handletimeout=%s" },
221 { Opt_echo_interval, "echo_interval=%s" },
222 { Opt_max_credits, "max_credits=%s" },
223 { Opt_snapshot, "snapshot=%s" },
224 { Opt_max_channels, "max_channels=%s" },
225 { Opt_compress, "compress=%s" },
226
227 { Opt_blank_user, "user=" },
228 { Opt_blank_user, "username=" },
229 { Opt_user, "user=%s" },
230 { Opt_user, "username=%s" },
231 { Opt_blank_pass, "pass=" },
232 { Opt_blank_pass, "password=" },
233 { Opt_pass, "pass=%s" },
234 { Opt_pass, "password=%s" },
235 { Opt_blank_ip, "ip=" },
236 { Opt_blank_ip, "addr=" },
237 { Opt_ip, "ip=%s" },
238 { Opt_ip, "addr=%s" },
239 { Opt_ignore, "unc=%s" },
240 { Opt_ignore, "target=%s" },
241 { Opt_ignore, "path=%s" },
242 { Opt_domain, "dom=%s" },
243 { Opt_domain, "domain=%s" },
244 { Opt_domain, "workgroup=%s" },
245 { Opt_srcaddr, "srcaddr=%s" },
246 { Opt_ignore, "prefixpath=%s" },
247 { Opt_iocharset, "iocharset=%s" },
248 { Opt_netbiosname, "netbiosname=%s" },
249 { Opt_servern, "servern=%s" },
250 { Opt_ver, "ver=%s" },
251 { Opt_vers, "vers=%s" },
252 { Opt_sec, "sec=%s" },
253 { Opt_cache, "cache=%s" },
254
255 { Opt_ignore, "cred" },
256 { Opt_ignore, "credentials" },
257 { Opt_ignore, "cred=%s" },
258 { Opt_ignore, "credentials=%s" },
259 { Opt_ignore, "guest" },
260 { Opt_ignore, "rw" },
261 { Opt_ignore, "ro" },
262 { Opt_ignore, "suid" },
263 { Opt_ignore, "nosuid" },
264 { Opt_ignore, "exec" },
265 { Opt_ignore, "noexec" },
266 { Opt_ignore, "nodev" },
267 { Opt_ignore, "noauto" },
268 { Opt_ignore, "dev" },
269 { Opt_ignore, "mand" },
270 { Opt_ignore, "nomand" },
271 { Opt_ignore, "relatime" },
272 { Opt_ignore, "_netdev" },
273 { Opt_rootfs, "rootfs" },
274
275 { Opt_err, NULL }
276 };
277
278 enum {
279 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
280 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
281 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
282 Opt_sec_ntlmv2i, Opt_sec_lanman,
283 Opt_sec_none,
284
285 Opt_sec_err
286 };
287
288 static const match_table_t cifs_secflavor_tokens = {
289 { Opt_sec_krb5, "krb5" },
290 { Opt_sec_krb5i, "krb5i" },
291 { Opt_sec_krb5p, "krb5p" },
292 { Opt_sec_ntlmsspi, "ntlmsspi" },
293 { Opt_sec_ntlmssp, "ntlmssp" },
294 { Opt_ntlm, "ntlm" },
295 { Opt_sec_ntlmi, "ntlmi" },
296 { Opt_sec_ntlmv2, "nontlm" },
297 { Opt_sec_ntlmv2, "ntlmv2" },
298 { Opt_sec_ntlmv2i, "ntlmv2i" },
299 { Opt_sec_lanman, "lanman" },
300 { Opt_sec_none, "none" },
301
302 { Opt_sec_err, NULL }
303 };
304
305 /* cache flavors */
306 enum {
307 Opt_cache_loose,
308 Opt_cache_strict,
309 Opt_cache_none,
310 Opt_cache_ro,
311 Opt_cache_rw,
312 Opt_cache_err
313 };
314
315 static const match_table_t cifs_cacheflavor_tokens = {
316 { Opt_cache_loose, "loose" },
317 { Opt_cache_strict, "strict" },
318 { Opt_cache_none, "none" },
319 { Opt_cache_ro, "ro" },
320 { Opt_cache_rw, "singleclient" },
321 { Opt_cache_err, NULL }
322 };
323
324 static const match_table_t cifs_smb_version_tokens = {
325 { Smb_1, SMB1_VERSION_STRING },
326 { Smb_20, SMB20_VERSION_STRING},
327 { Smb_21, SMB21_VERSION_STRING },
328 { Smb_30, SMB30_VERSION_STRING },
329 { Smb_302, SMB302_VERSION_STRING },
330 { Smb_302, ALT_SMB302_VERSION_STRING },
331 { Smb_311, SMB311_VERSION_STRING },
332 { Smb_311, ALT_SMB311_VERSION_STRING },
333 { Smb_3any, SMB3ANY_VERSION_STRING },
334 { Smb_default, SMBDEFAULT_VERSION_STRING },
335 { Smb_version_err, NULL }
336 };
337
338 static int ip_connect(struct TCP_Server_Info *server);
339 static int generic_ip_connect(struct TCP_Server_Info *server);
340 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
341 static void cifs_prune_tlinks(struct work_struct *work);
342 static char *extract_hostname(const char *unc);
343
344 /*
345 * Resolve hostname and set ip addr in tcp ses. Useful for hostnames that may
346 * get their ip addresses changed at some point.
347 *
348 * This should be called with server->srv_mutex held.
349 */
350 #ifdef CONFIG_CIFS_DFS_UPCALL
351 static int reconn_set_ipaddr(struct TCP_Server_Info *server)
352 {
353 int rc;
354 int len;
355 char *unc, *ipaddr = NULL;
356
357 if (!server->hostname)
358 return -EINVAL;
359
360 len = strlen(server->hostname) + 3;
361
362 unc = kmalloc(len, GFP_KERNEL);
363 if (!unc) {
364 cifs_dbg(FYI, "%s: failed to create UNC path\n", __func__);
365 return -ENOMEM;
366 }
367 scnprintf(unc, len, "\\\\%s", server->hostname);
368
369 rc = dns_resolve_server_name_to_ip(unc, &ipaddr);
370 kfree(unc);
371
372 if (rc < 0) {
373 cifs_dbg(FYI, "%s: failed to resolve server part of %s to IP: %d\n",
374 __func__, server->hostname, rc);
375 return rc;
376 }
377
378 rc = cifs_convert_address((struct sockaddr *)&server->dstaddr, ipaddr,
379 strlen(ipaddr));
380 kfree(ipaddr);
381
382 return !rc ? -1 : 0;
383 }
384 #else
385 static inline int reconn_set_ipaddr(struct TCP_Server_Info *server)
386 {
387 return 0;
388 }
389 #endif
390
391 #ifdef CONFIG_CIFS_DFS_UPCALL
392 struct super_cb_data {
393 struct TCP_Server_Info *server;
394 struct super_block *sb;
395 };
396
397 /* These functions must be called with server->srv_mutex held */
398
399 static void super_cb(struct super_block *sb, void *arg)
400 {
401 struct super_cb_data *d = arg;
402 struct cifs_sb_info *cifs_sb;
403 struct cifs_tcon *tcon;
404
405 if (d->sb)
406 return;
407
408 cifs_sb = CIFS_SB(sb);
409 tcon = cifs_sb_master_tcon(cifs_sb);
410 if (tcon->ses->server == d->server)
411 d->sb = sb;
412 }
413
414 static struct super_block *get_tcp_super(struct TCP_Server_Info *server)
415 {
416 struct super_cb_data d = {
417 .server = server,
418 .sb = NULL,
419 };
420
421 iterate_supers_type(&cifs_fs_type, super_cb, &d);
422
423 if (unlikely(!d.sb))
424 return ERR_PTR(-ENOENT);
425 /*
426 * Grab an active reference in order to prevent automounts (DFS links)
427 * of expiring and then freeing up our cifs superblock pointer while
428 * we're doing failover.
429 */
430 cifs_sb_active(d.sb);
431 return d.sb;
432 }
433
434 static inline void put_tcp_super(struct super_block *sb)
435 {
436 if (!IS_ERR_OR_NULL(sb))
437 cifs_sb_deactive(sb);
438 }
439
440 static void reconn_inval_dfs_target(struct TCP_Server_Info *server,
441 struct cifs_sb_info *cifs_sb,
442 struct dfs_cache_tgt_list *tgt_list,
443 struct dfs_cache_tgt_iterator **tgt_it)
444 {
445 const char *name;
446
447 if (!cifs_sb || !cifs_sb->origin_fullpath || !tgt_list ||
448 !server->nr_targets)
449 return;
450
451 if (!*tgt_it) {
452 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
453 } else {
454 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
455 if (!*tgt_it)
456 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
457 }
458
459 cifs_dbg(FYI, "%s: UNC: %s\n", __func__, cifs_sb->origin_fullpath);
460
461 name = dfs_cache_get_tgt_name(*tgt_it);
462
463 kfree(server->hostname);
464
465 server->hostname = extract_hostname(name);
466 if (IS_ERR(server->hostname)) {
467 cifs_dbg(FYI,
468 "%s: failed to extract hostname from target: %ld\n",
469 __func__, PTR_ERR(server->hostname));
470 }
471 }
472
473 static inline int reconn_setup_dfs_targets(struct cifs_sb_info *cifs_sb,
474 struct dfs_cache_tgt_list *tl,
475 struct dfs_cache_tgt_iterator **it)
476 {
477 if (!cifs_sb->origin_fullpath)
478 return -EOPNOTSUPP;
479 return dfs_cache_noreq_find(cifs_sb->origin_fullpath + 1, NULL, tl);
480 }
481 #endif
482
483 /*
484 * cifs tcp session reconnection
485 *
486 * mark tcp session as reconnecting so temporarily locked
487 * mark all smb sessions as reconnecting for tcp session
488 * reconnect tcp session
489 * wake up waiters on reconnection? - (not needed currently)
490 */
491 int
492 cifs_reconnect(struct TCP_Server_Info *server)
493 {
494 int rc = 0;
495 struct list_head *tmp, *tmp2;
496 struct cifs_ses *ses;
497 struct cifs_tcon *tcon;
498 struct mid_q_entry *mid_entry;
499 struct list_head retry_list;
500 #ifdef CONFIG_CIFS_DFS_UPCALL
501 struct super_block *sb = NULL;
502 struct cifs_sb_info *cifs_sb = NULL;
503 struct dfs_cache_tgt_list tgt_list = {0};
504 struct dfs_cache_tgt_iterator *tgt_it = NULL;
505 #endif
506
507 spin_lock(&GlobalMid_Lock);
508 server->nr_targets = 1;
509 #ifdef CONFIG_CIFS_DFS_UPCALL
510 spin_unlock(&GlobalMid_Lock);
511 sb = get_tcp_super(server);
512 if (IS_ERR(sb)) {
513 rc = PTR_ERR(sb);
514 cifs_dbg(FYI, "%s: will not do DFS failover: rc = %d\n",
515 __func__, rc);
516 sb = NULL;
517 } else {
518 cifs_sb = CIFS_SB(sb);
519
520 rc = reconn_setup_dfs_targets(cifs_sb, &tgt_list, &tgt_it);
521 if (rc && (rc != -EOPNOTSUPP)) {
522 cifs_server_dbg(VFS, "%s: no target servers for DFS failover\n",
523 __func__);
524 } else {
525 server->nr_targets = dfs_cache_get_nr_tgts(&tgt_list);
526 }
527 }
528 cifs_dbg(FYI, "%s: will retry %d target(s)\n", __func__,
529 server->nr_targets);
530 spin_lock(&GlobalMid_Lock);
531 #endif
532 if (server->tcpStatus == CifsExiting) {
533 /* the demux thread will exit normally
534 next time through the loop */
535 spin_unlock(&GlobalMid_Lock);
536 #ifdef CONFIG_CIFS_DFS_UPCALL
537 dfs_cache_free_tgts(&tgt_list);
538 put_tcp_super(sb);
539 #endif
540 return rc;
541 } else
542 server->tcpStatus = CifsNeedReconnect;
543 spin_unlock(&GlobalMid_Lock);
544 server->maxBuf = 0;
545 server->max_read = 0;
546
547 cifs_dbg(FYI, "Mark tcp session as need reconnect\n");
548 trace_smb3_reconnect(server->CurrentMid, server->hostname);
549
550 /* before reconnecting the tcp session, mark the smb session (uid)
551 and the tid bad so they are not used until reconnected */
552 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
553 __func__);
554 spin_lock(&cifs_tcp_ses_lock);
555 list_for_each(tmp, &server->smb_ses_list) {
556 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
557 ses->need_reconnect = true;
558 list_for_each(tmp2, &ses->tcon_list) {
559 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
560 tcon->need_reconnect = true;
561 }
562 if (ses->tcon_ipc)
563 ses->tcon_ipc->need_reconnect = true;
564 }
565 spin_unlock(&cifs_tcp_ses_lock);
566
567 /* do not want to be sending data on a socket we are freeing */
568 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
569 mutex_lock(&server->srv_mutex);
570 if (server->ssocket) {
571 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
572 server->ssocket->state, server->ssocket->flags);
573 kernel_sock_shutdown(server->ssocket, SHUT_WR);
574 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
575 server->ssocket->state, server->ssocket->flags);
576 sock_release(server->ssocket);
577 server->ssocket = NULL;
578 }
579 server->sequence_number = 0;
580 server->session_estab = false;
581 kfree(server->session_key.response);
582 server->session_key.response = NULL;
583 server->session_key.len = 0;
584 server->lstrp = jiffies;
585
586 /* mark submitted MIDs for retry and issue callback */
587 INIT_LIST_HEAD(&retry_list);
588 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
589 spin_lock(&GlobalMid_Lock);
590 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
591 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
592 kref_get(&mid_entry->refcount);
593 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
594 mid_entry->mid_state = MID_RETRY_NEEDED;
595 list_move(&mid_entry->qhead, &retry_list);
596 mid_entry->mid_flags |= MID_DELETED;
597 }
598 spin_unlock(&GlobalMid_Lock);
599 mutex_unlock(&server->srv_mutex);
600
601 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
602 list_for_each_safe(tmp, tmp2, &retry_list) {
603 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
604 list_del_init(&mid_entry->qhead);
605 mid_entry->callback(mid_entry);
606 cifs_mid_q_entry_release(mid_entry);
607 }
608
609 if (cifs_rdma_enabled(server)) {
610 mutex_lock(&server->srv_mutex);
611 smbd_destroy(server);
612 mutex_unlock(&server->srv_mutex);
613 }
614
615 do {
616 try_to_freeze();
617
618 mutex_lock(&server->srv_mutex);
619 /*
620 * Set up next DFS target server (if any) for reconnect. If DFS
621 * feature is disabled, then we will retry last server we
622 * connected to before.
623 */
624 if (cifs_rdma_enabled(server))
625 rc = smbd_reconnect(server);
626 else
627 rc = generic_ip_connect(server);
628 if (rc) {
629 cifs_dbg(FYI, "reconnect error %d\n", rc);
630 #ifdef CONFIG_CIFS_DFS_UPCALL
631 reconn_inval_dfs_target(server, cifs_sb, &tgt_list,
632 &tgt_it);
633 #endif
634 rc = reconn_set_ipaddr(server);
635 if (rc) {
636 cifs_dbg(FYI, "%s: failed to resolve hostname: %d\n",
637 __func__, rc);
638 }
639 mutex_unlock(&server->srv_mutex);
640 msleep(3000);
641 } else {
642 atomic_inc(&tcpSesReconnectCount);
643 set_credits(server, 1);
644 spin_lock(&GlobalMid_Lock);
645 if (server->tcpStatus != CifsExiting)
646 server->tcpStatus = CifsNeedNegotiate;
647 spin_unlock(&GlobalMid_Lock);
648 mutex_unlock(&server->srv_mutex);
649 }
650 } while (server->tcpStatus == CifsNeedReconnect);
651
652 #ifdef CONFIG_CIFS_DFS_UPCALL
653 if (tgt_it) {
654 rc = dfs_cache_noreq_update_tgthint(cifs_sb->origin_fullpath + 1,
655 tgt_it);
656 if (rc) {
657 cifs_server_dbg(VFS, "%s: failed to update DFS target hint: rc = %d\n",
658 __func__, rc);
659 }
660 rc = dfs_cache_update_vol(cifs_sb->origin_fullpath, server);
661 if (rc) {
662 cifs_server_dbg(VFS, "%s: failed to update vol info in DFS cache: rc = %d\n",
663 __func__, rc);
664 }
665 dfs_cache_free_tgts(&tgt_list);
666
667 }
668
669 put_tcp_super(sb);
670 #endif
671 if (server->tcpStatus == CifsNeedNegotiate)
672 mod_delayed_work(cifsiod_wq, &server->echo, 0);
673
674 return rc;
675 }
676
677 static void
678 cifs_echo_request(struct work_struct *work)
679 {
680 int rc;
681 struct TCP_Server_Info *server = container_of(work,
682 struct TCP_Server_Info, echo.work);
683 unsigned long echo_interval;
684
685 /*
686 * If we need to renegotiate, set echo interval to zero to
687 * immediately call echo service where we can renegotiate.
688 */
689 if (server->tcpStatus == CifsNeedNegotiate)
690 echo_interval = 0;
691 else
692 echo_interval = server->echo_interval;
693
694 /*
695 * We cannot send an echo if it is disabled.
696 * Also, no need to ping if we got a response recently.
697 */
698
699 if (server->tcpStatus == CifsNeedReconnect ||
700 server->tcpStatus == CifsExiting ||
701 server->tcpStatus == CifsNew ||
702 (server->ops->can_echo && !server->ops->can_echo(server)) ||
703 time_before(jiffies, server->lstrp + echo_interval - HZ))
704 goto requeue_echo;
705
706 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
707 if (rc)
708 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
709 server->hostname);
710
711 requeue_echo:
712 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
713 }
714
715 static bool
716 allocate_buffers(struct TCP_Server_Info *server)
717 {
718 if (!server->bigbuf) {
719 server->bigbuf = (char *)cifs_buf_get();
720 if (!server->bigbuf) {
721 cifs_server_dbg(VFS, "No memory for large SMB response\n");
722 msleep(3000);
723 /* retry will check if exiting */
724 return false;
725 }
726 } else if (server->large_buf) {
727 /* we are reusing a dirty large buf, clear its start */
728 memset(server->bigbuf, 0, HEADER_SIZE(server));
729 }
730
731 if (!server->smallbuf) {
732 server->smallbuf = (char *)cifs_small_buf_get();
733 if (!server->smallbuf) {
734 cifs_server_dbg(VFS, "No memory for SMB response\n");
735 msleep(1000);
736 /* retry will check if exiting */
737 return false;
738 }
739 /* beginning of smb buffer is cleared in our buf_get */
740 } else {
741 /* if existing small buf clear beginning */
742 memset(server->smallbuf, 0, HEADER_SIZE(server));
743 }
744
745 return true;
746 }
747
748 static bool
749 server_unresponsive(struct TCP_Server_Info *server)
750 {
751 /*
752 * We need to wait 3 echo intervals to make sure we handle such
753 * situations right:
754 * 1s client sends a normal SMB request
755 * 2s client gets a response
756 * 30s echo workqueue job pops, and decides we got a response recently
757 * and don't need to send another
758 * ...
759 * 65s kernel_recvmsg times out, and we see that we haven't gotten
760 * a response in >60s.
761 */
762 if ((server->tcpStatus == CifsGood ||
763 server->tcpStatus == CifsNeedNegotiate) &&
764 time_after(jiffies, server->lstrp + 3 * server->echo_interval)) {
765 cifs_server_dbg(VFS, "has not responded in %lu seconds. Reconnecting...\n",
766 (3 * server->echo_interval) / HZ);
767 cifs_reconnect(server);
768 wake_up(&server->response_q);
769 return true;
770 }
771
772 return false;
773 }
774
775 static inline bool
776 zero_credits(struct TCP_Server_Info *server)
777 {
778 int val;
779
780 spin_lock(&server->req_lock);
781 val = server->credits + server->echo_credits + server->oplock_credits;
782 if (server->in_flight == 0 && val == 0) {
783 spin_unlock(&server->req_lock);
784 return true;
785 }
786 spin_unlock(&server->req_lock);
787 return false;
788 }
789
790 static int
791 cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
792 {
793 int length = 0;
794 int total_read;
795
796 smb_msg->msg_control = NULL;
797 smb_msg->msg_controllen = 0;
798
799 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
800 try_to_freeze();
801
802 /* reconnect if no credits and no requests in flight */
803 if (zero_credits(server)) {
804 cifs_reconnect(server);
805 return -ECONNABORTED;
806 }
807
808 if (server_unresponsive(server))
809 return -ECONNABORTED;
810 if (cifs_rdma_enabled(server) && server->smbd_conn)
811 length = smbd_recv(server->smbd_conn, smb_msg);
812 else
813 length = sock_recvmsg(server->ssocket, smb_msg, 0);
814
815 if (server->tcpStatus == CifsExiting)
816 return -ESHUTDOWN;
817
818 if (server->tcpStatus == CifsNeedReconnect) {
819 cifs_reconnect(server);
820 return -ECONNABORTED;
821 }
822
823 if (length == -ERESTARTSYS ||
824 length == -EAGAIN ||
825 length == -EINTR) {
826 /*
827 * Minimum sleep to prevent looping, allowing socket
828 * to clear and app threads to set tcpStatus
829 * CifsNeedReconnect if server hung.
830 */
831 usleep_range(1000, 2000);
832 length = 0;
833 continue;
834 }
835
836 if (length <= 0) {
837 cifs_dbg(FYI, "Received no data or error: %d\n", length);
838 cifs_reconnect(server);
839 return -ECONNABORTED;
840 }
841 }
842 return total_read;
843 }
844
845 int
846 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
847 unsigned int to_read)
848 {
849 struct msghdr smb_msg;
850 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
851 iov_iter_kvec(&smb_msg.msg_iter, READ, &iov, 1, to_read);
852
853 return cifs_readv_from_socket(server, &smb_msg);
854 }
855
856 int
857 cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
858 unsigned int page_offset, unsigned int to_read)
859 {
860 struct msghdr smb_msg;
861 struct bio_vec bv = {
862 .bv_page = page, .bv_len = to_read, .bv_offset = page_offset};
863 iov_iter_bvec(&smb_msg.msg_iter, READ, &bv, 1, to_read);
864 return cifs_readv_from_socket(server, &smb_msg);
865 }
866
867 static bool
868 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
869 {
870 /*
871 * The first byte big endian of the length field,
872 * is actually not part of the length but the type
873 * with the most common, zero, as regular data.
874 */
875 switch (type) {
876 case RFC1002_SESSION_MESSAGE:
877 /* Regular SMB response */
878 return true;
879 case RFC1002_SESSION_KEEP_ALIVE:
880 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
881 break;
882 case RFC1002_POSITIVE_SESSION_RESPONSE:
883 cifs_dbg(FYI, "RFC 1002 positive session response\n");
884 break;
885 case RFC1002_NEGATIVE_SESSION_RESPONSE:
886 /*
887 * We get this from Windows 98 instead of an error on
888 * SMB negprot response.
889 */
890 cifs_dbg(FYI, "RFC 1002 negative session response\n");
891 /* give server a second to clean up */
892 msleep(1000);
893 /*
894 * Always try 445 first on reconnect since we get NACK
895 * on some if we ever connected to port 139 (the NACK
896 * is since we do not begin with RFC1001 session
897 * initialize frame).
898 */
899 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
900 cifs_reconnect(server);
901 wake_up(&server->response_q);
902 break;
903 default:
904 cifs_server_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
905 cifs_reconnect(server);
906 }
907
908 return false;
909 }
910
911 void
912 dequeue_mid(struct mid_q_entry *mid, bool malformed)
913 {
914 #ifdef CONFIG_CIFS_STATS2
915 mid->when_received = jiffies;
916 #endif
917 spin_lock(&GlobalMid_Lock);
918 if (!malformed)
919 mid->mid_state = MID_RESPONSE_RECEIVED;
920 else
921 mid->mid_state = MID_RESPONSE_MALFORMED;
922 /*
923 * Trying to handle/dequeue a mid after the send_recv()
924 * function has finished processing it is a bug.
925 */
926 if (mid->mid_flags & MID_DELETED)
927 printk_once(KERN_WARNING
928 "trying to dequeue a deleted mid\n");
929 else {
930 list_del_init(&mid->qhead);
931 mid->mid_flags |= MID_DELETED;
932 }
933 spin_unlock(&GlobalMid_Lock);
934 }
935
936 static unsigned int
937 smb2_get_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
938 {
939 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
940
941 /*
942 * SMB1 does not use credits.
943 */
944 if (server->vals->header_preamble_size)
945 return 0;
946
947 return le16_to_cpu(shdr->CreditRequest);
948 }
949
950 static void
951 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
952 char *buf, int malformed)
953 {
954 if (server->ops->check_trans2 &&
955 server->ops->check_trans2(mid, server, buf, malformed))
956 return;
957 mid->credits_received = smb2_get_credits_from_hdr(buf, server);
958 mid->resp_buf = buf;
959 mid->large_buf = server->large_buf;
960 /* Was previous buf put in mpx struct for multi-rsp? */
961 if (!mid->multiRsp) {
962 /* smb buffer will be freed by user thread */
963 if (server->large_buf)
964 server->bigbuf = NULL;
965 else
966 server->smallbuf = NULL;
967 }
968 dequeue_mid(mid, malformed);
969 }
970
971 static void clean_demultiplex_info(struct TCP_Server_Info *server)
972 {
973 int length;
974
975 /* take it off the list, if it's not already */
976 spin_lock(&cifs_tcp_ses_lock);
977 list_del_init(&server->tcp_ses_list);
978 spin_unlock(&cifs_tcp_ses_lock);
979
980 spin_lock(&GlobalMid_Lock);
981 server->tcpStatus = CifsExiting;
982 spin_unlock(&GlobalMid_Lock);
983 wake_up_all(&server->response_q);
984
985 /* check if we have blocked requests that need to free */
986 spin_lock(&server->req_lock);
987 if (server->credits <= 0)
988 server->credits = 1;
989 spin_unlock(&server->req_lock);
990 /*
991 * Although there should not be any requests blocked on this queue it
992 * can not hurt to be paranoid and try to wake up requests that may
993 * haven been blocked when more than 50 at time were on the wire to the
994 * same server - they now will see the session is in exit state and get
995 * out of SendReceive.
996 */
997 wake_up_all(&server->request_q);
998 /* give those requests time to exit */
999 msleep(125);
1000 if (cifs_rdma_enabled(server))
1001 smbd_destroy(server);
1002 if (server->ssocket) {
1003 sock_release(server->ssocket);
1004 server->ssocket = NULL;
1005 }
1006
1007 if (!list_empty(&server->pending_mid_q)) {
1008 struct list_head dispose_list;
1009 struct mid_q_entry *mid_entry;
1010 struct list_head *tmp, *tmp2;
1011
1012 INIT_LIST_HEAD(&dispose_list);
1013 spin_lock(&GlobalMid_Lock);
1014 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
1015 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
1016 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
1017 kref_get(&mid_entry->refcount);
1018 mid_entry->mid_state = MID_SHUTDOWN;
1019 list_move(&mid_entry->qhead, &dispose_list);
1020 mid_entry->mid_flags |= MID_DELETED;
1021 }
1022 spin_unlock(&GlobalMid_Lock);
1023
1024 /* now walk dispose list and issue callbacks */
1025 list_for_each_safe(tmp, tmp2, &dispose_list) {
1026 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
1027 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
1028 list_del_init(&mid_entry->qhead);
1029 mid_entry->callback(mid_entry);
1030 cifs_mid_q_entry_release(mid_entry);
1031 }
1032 /* 1/8th of sec is more than enough time for them to exit */
1033 msleep(125);
1034 }
1035
1036 if (!list_empty(&server->pending_mid_q)) {
1037 /*
1038 * mpx threads have not exited yet give them at least the smb
1039 * send timeout time for long ops.
1040 *
1041 * Due to delays on oplock break requests, we need to wait at
1042 * least 45 seconds before giving up on a request getting a
1043 * response and going ahead and killing cifsd.
1044 */
1045 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
1046 msleep(46000);
1047 /*
1048 * If threads still have not exited they are probably never
1049 * coming home not much else we can do but free the memory.
1050 */
1051 }
1052
1053 kfree(server->hostname);
1054 kfree(server);
1055
1056 length = atomic_dec_return(&tcpSesAllocCount);
1057 if (length > 0)
1058 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1059 }
1060
1061 static int
1062 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1063 {
1064 int length;
1065 char *buf = server->smallbuf;
1066 unsigned int pdu_length = server->pdu_size;
1067
1068 /* make sure this will fit in a large buffer */
1069 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
1070 server->vals->header_preamble_size) {
1071 cifs_server_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
1072 cifs_reconnect(server);
1073 wake_up(&server->response_q);
1074 return -ECONNABORTED;
1075 }
1076
1077 /* switch to large buffer if too big for a small one */
1078 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
1079 server->large_buf = true;
1080 memcpy(server->bigbuf, buf, server->total_read);
1081 buf = server->bigbuf;
1082 }
1083
1084 /* now read the rest */
1085 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
1086 pdu_length - HEADER_SIZE(server) + 1
1087 + server->vals->header_preamble_size);
1088
1089 if (length < 0)
1090 return length;
1091 server->total_read += length;
1092
1093 dump_smb(buf, server->total_read);
1094
1095 return cifs_handle_standard(server, mid);
1096 }
1097
1098 int
1099 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1100 {
1101 char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
1102 int length;
1103
1104 /*
1105 * We know that we received enough to get to the MID as we
1106 * checked the pdu_length earlier. Now check to see
1107 * if the rest of the header is OK. We borrow the length
1108 * var for the rest of the loop to avoid a new stack var.
1109 *
1110 * 48 bytes is enough to display the header and a little bit
1111 * into the payload for debugging purposes.
1112 */
1113 length = server->ops->check_message(buf, server->total_read, server);
1114 if (length != 0)
1115 cifs_dump_mem("Bad SMB: ", buf,
1116 min_t(unsigned int, server->total_read, 48));
1117
1118 if (server->ops->is_session_expired &&
1119 server->ops->is_session_expired(buf)) {
1120 cifs_reconnect(server);
1121 wake_up(&server->response_q);
1122 return -1;
1123 }
1124
1125 if (server->ops->is_status_pending &&
1126 server->ops->is_status_pending(buf, server))
1127 return -1;
1128
1129 if (!mid)
1130 return length;
1131
1132 handle_mid(mid, server, buf, length);
1133 return 0;
1134 }
1135
1136 static void
1137 smb2_add_credits_from_hdr(char *buffer, struct TCP_Server_Info *server)
1138 {
1139 struct smb2_sync_hdr *shdr = (struct smb2_sync_hdr *)buffer;
1140
1141 /*
1142 * SMB1 does not use credits.
1143 */
1144 if (server->vals->header_preamble_size)
1145 return;
1146
1147 if (shdr->CreditRequest) {
1148 spin_lock(&server->req_lock);
1149 server->credits += le16_to_cpu(shdr->CreditRequest);
1150 spin_unlock(&server->req_lock);
1151 wake_up(&server->request_q);
1152 }
1153 }
1154
1155
1156 static int
1157 cifs_demultiplex_thread(void *p)
1158 {
1159 int i, num_mids, length;
1160 struct TCP_Server_Info *server = p;
1161 unsigned int pdu_length;
1162 unsigned int next_offset;
1163 char *buf = NULL;
1164 struct task_struct *task_to_wake = NULL;
1165 struct mid_q_entry *mids[MAX_COMPOUND];
1166 char *bufs[MAX_COMPOUND];
1167
1168 current->flags |= PF_MEMALLOC;
1169 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
1170
1171 length = atomic_inc_return(&tcpSesAllocCount);
1172 if (length > 1)
1173 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
1174
1175 set_freezable();
1176 allow_kernel_signal(SIGKILL);
1177 while (server->tcpStatus != CifsExiting) {
1178 if (try_to_freeze())
1179 continue;
1180
1181 if (!allocate_buffers(server))
1182 continue;
1183
1184 server->large_buf = false;
1185 buf = server->smallbuf;
1186 pdu_length = 4; /* enough to get RFC1001 header */
1187
1188 length = cifs_read_from_socket(server, buf, pdu_length);
1189 if (length < 0)
1190 continue;
1191
1192 if (server->vals->header_preamble_size == 0)
1193 server->total_read = 0;
1194 else
1195 server->total_read = length;
1196
1197 /*
1198 * The right amount was read from socket - 4 bytes,
1199 * so we can now interpret the length field.
1200 */
1201 pdu_length = get_rfc1002_length(buf);
1202
1203 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
1204 if (!is_smb_response(server, buf[0]))
1205 continue;
1206 next_pdu:
1207 server->pdu_size = pdu_length;
1208
1209 /* make sure we have enough to get to the MID */
1210 if (server->pdu_size < HEADER_SIZE(server) - 1 -
1211 server->vals->header_preamble_size) {
1212 cifs_server_dbg(VFS, "SMB response too short (%u bytes)\n",
1213 server->pdu_size);
1214 cifs_reconnect(server);
1215 wake_up(&server->response_q);
1216 continue;
1217 }
1218
1219 /* read down to the MID */
1220 length = cifs_read_from_socket(server,
1221 buf + server->vals->header_preamble_size,
1222 HEADER_SIZE(server) - 1
1223 - server->vals->header_preamble_size);
1224 if (length < 0)
1225 continue;
1226 server->total_read += length;
1227
1228 if (server->ops->next_header) {
1229 next_offset = server->ops->next_header(buf);
1230 if (next_offset)
1231 server->pdu_size = next_offset;
1232 }
1233
1234 memset(mids, 0, sizeof(mids));
1235 memset(bufs, 0, sizeof(bufs));
1236 num_mids = 0;
1237
1238 if (server->ops->is_transform_hdr &&
1239 server->ops->receive_transform &&
1240 server->ops->is_transform_hdr(buf)) {
1241 length = server->ops->receive_transform(server,
1242 mids,
1243 bufs,
1244 &num_mids);
1245 } else {
1246 mids[0] = server->ops->find_mid(server, buf);
1247 bufs[0] = buf;
1248 num_mids = 1;
1249
1250 if (!mids[0] || !mids[0]->receive)
1251 length = standard_receive3(server, mids[0]);
1252 else
1253 length = mids[0]->receive(server, mids[0]);
1254 }
1255
1256 if (length < 0) {
1257 for (i = 0; i < num_mids; i++)
1258 if (mids[i])
1259 cifs_mid_q_entry_release(mids[i]);
1260 continue;
1261 }
1262
1263 server->lstrp = jiffies;
1264
1265 for (i = 0; i < num_mids; i++) {
1266 if (mids[i] != NULL) {
1267 mids[i]->resp_buf_size = server->pdu_size;
1268
1269 if (!mids[i]->multiRsp || mids[i]->multiEnd)
1270 mids[i]->callback(mids[i]);
1271
1272 cifs_mid_q_entry_release(mids[i]);
1273 } else if (server->ops->is_oplock_break &&
1274 server->ops->is_oplock_break(bufs[i],
1275 server)) {
1276 smb2_add_credits_from_hdr(bufs[i], server);
1277 cifs_dbg(FYI, "Received oplock break\n");
1278 } else {
1279 cifs_server_dbg(VFS, "No task to wake, unknown frame "
1280 "received! NumMids %d\n",
1281 atomic_read(&midCount));
1282 cifs_dump_mem("Received Data is: ", bufs[i],
1283 HEADER_SIZE(server));
1284 smb2_add_credits_from_hdr(bufs[i], server);
1285 #ifdef CONFIG_CIFS_DEBUG2
1286 if (server->ops->dump_detail)
1287 server->ops->dump_detail(bufs[i],
1288 server);
1289 cifs_dump_mids(server);
1290 #endif /* CIFS_DEBUG2 */
1291 }
1292 }
1293
1294 if (pdu_length > server->pdu_size) {
1295 if (!allocate_buffers(server))
1296 continue;
1297 pdu_length -= server->pdu_size;
1298 server->total_read = 0;
1299 server->large_buf = false;
1300 buf = server->smallbuf;
1301 goto next_pdu;
1302 }
1303 } /* end while !EXITING */
1304
1305 /* buffer usually freed in free_mid - need to free it here on exit */
1306 cifs_buf_release(server->bigbuf);
1307 if (server->smallbuf) /* no sense logging a debug message if NULL */
1308 cifs_small_buf_release(server->smallbuf);
1309
1310 task_to_wake = xchg(&server->tsk, NULL);
1311 clean_demultiplex_info(server);
1312
1313 /* if server->tsk was NULL then wait for a signal before exiting */
1314 if (!task_to_wake) {
1315 set_current_state(TASK_INTERRUPTIBLE);
1316 while (!signal_pending(current)) {
1317 schedule();
1318 set_current_state(TASK_INTERRUPTIBLE);
1319 }
1320 set_current_state(TASK_RUNNING);
1321 }
1322
1323 module_put_and_exit(0);
1324 }
1325
1326 /* extract the host portion of the UNC string */
1327 static char *
1328 extract_hostname(const char *unc)
1329 {
1330 const char *src;
1331 char *dst, *delim;
1332 unsigned int len;
1333
1334 /* skip double chars at beginning of string */
1335 /* BB: check validity of these bytes? */
1336 if (strlen(unc) < 3)
1337 return ERR_PTR(-EINVAL);
1338 for (src = unc; *src && *src == '\\'; src++)
1339 ;
1340 if (!*src)
1341 return ERR_PTR(-EINVAL);
1342
1343 /* delimiter between hostname and sharename is always '\\' now */
1344 delim = strchr(src, '\\');
1345 if (!delim)
1346 return ERR_PTR(-EINVAL);
1347
1348 len = delim - src;
1349 dst = kmalloc((len + 1), GFP_KERNEL);
1350 if (dst == NULL)
1351 return ERR_PTR(-ENOMEM);
1352
1353 memcpy(dst, src, len);
1354 dst[len] = '\0';
1355
1356 return dst;
1357 }
1358
1359 static int get_option_ul(substring_t args[], unsigned long *option)
1360 {
1361 int rc;
1362 char *string;
1363
1364 string = match_strdup(args);
1365 if (string == NULL)
1366 return -ENOMEM;
1367 rc = kstrtoul(string, 0, option);
1368 kfree(string);
1369
1370 return rc;
1371 }
1372
1373 static int get_option_uid(substring_t args[], kuid_t *result)
1374 {
1375 unsigned long value;
1376 kuid_t uid;
1377 int rc;
1378
1379 rc = get_option_ul(args, &value);
1380 if (rc)
1381 return rc;
1382
1383 uid = make_kuid(current_user_ns(), value);
1384 if (!uid_valid(uid))
1385 return -EINVAL;
1386
1387 *result = uid;
1388 return 0;
1389 }
1390
1391 static int get_option_gid(substring_t args[], kgid_t *result)
1392 {
1393 unsigned long value;
1394 kgid_t gid;
1395 int rc;
1396
1397 rc = get_option_ul(args, &value);
1398 if (rc)
1399 return rc;
1400
1401 gid = make_kgid(current_user_ns(), value);
1402 if (!gid_valid(gid))
1403 return -EINVAL;
1404
1405 *result = gid;
1406 return 0;
1407 }
1408
1409 static int cifs_parse_security_flavors(char *value,
1410 struct smb_vol *vol)
1411 {
1412
1413 substring_t args[MAX_OPT_ARGS];
1414
1415 /*
1416 * With mount options, the last one should win. Reset any existing
1417 * settings back to default.
1418 */
1419 vol->sectype = Unspecified;
1420 vol->sign = false;
1421
1422 switch (match_token(value, cifs_secflavor_tokens, args)) {
1423 case Opt_sec_krb5p:
1424 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1425 return 1;
1426 case Opt_sec_krb5i:
1427 vol->sign = true;
1428 /* Fallthrough */
1429 case Opt_sec_krb5:
1430 vol->sectype = Kerberos;
1431 break;
1432 case Opt_sec_ntlmsspi:
1433 vol->sign = true;
1434 /* Fallthrough */
1435 case Opt_sec_ntlmssp:
1436 vol->sectype = RawNTLMSSP;
1437 break;
1438 case Opt_sec_ntlmi:
1439 vol->sign = true;
1440 /* Fallthrough */
1441 case Opt_ntlm:
1442 vol->sectype = NTLM;
1443 break;
1444 case Opt_sec_ntlmv2i:
1445 vol->sign = true;
1446 /* Fallthrough */
1447 case Opt_sec_ntlmv2:
1448 vol->sectype = NTLMv2;
1449 break;
1450 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1451 case Opt_sec_lanman:
1452 vol->sectype = LANMAN;
1453 break;
1454 #endif
1455 case Opt_sec_none:
1456 vol->nullauth = 1;
1457 break;
1458 default:
1459 cifs_dbg(VFS, "bad security option: %s\n", value);
1460 return 1;
1461 }
1462
1463 return 0;
1464 }
1465
1466 static int
1467 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1468 {
1469 substring_t args[MAX_OPT_ARGS];
1470
1471 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1472 case Opt_cache_loose:
1473 vol->direct_io = false;
1474 vol->strict_io = false;
1475 vol->cache_ro = false;
1476 vol->cache_rw = false;
1477 break;
1478 case Opt_cache_strict:
1479 vol->direct_io = false;
1480 vol->strict_io = true;
1481 vol->cache_ro = false;
1482 vol->cache_rw = false;
1483 break;
1484 case Opt_cache_none:
1485 vol->direct_io = true;
1486 vol->strict_io = false;
1487 vol->cache_ro = false;
1488 vol->cache_rw = false;
1489 break;
1490 case Opt_cache_ro:
1491 vol->direct_io = false;
1492 vol->strict_io = false;
1493 vol->cache_ro = true;
1494 vol->cache_rw = false;
1495 break;
1496 case Opt_cache_rw:
1497 vol->direct_io = false;
1498 vol->strict_io = false;
1499 vol->cache_ro = false;
1500 vol->cache_rw = true;
1501 break;
1502 default:
1503 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1504 return 1;
1505 }
1506 return 0;
1507 }
1508
1509 static int
1510 cifs_parse_smb_version(char *value, struct smb_vol *vol, bool is_smb3)
1511 {
1512 substring_t args[MAX_OPT_ARGS];
1513
1514 switch (match_token(value, cifs_smb_version_tokens, args)) {
1515 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1516 case Smb_1:
1517 if (disable_legacy_dialects) {
1518 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1519 return 1;
1520 }
1521 if (is_smb3) {
1522 cifs_dbg(VFS, "vers=1.0 (cifs) not permitted when mounting with smb3\n");
1523 return 1;
1524 }
1525 vol->ops = &smb1_operations;
1526 vol->vals = &smb1_values;
1527 break;
1528 case Smb_20:
1529 if (disable_legacy_dialects) {
1530 cifs_dbg(VFS, "mount with legacy dialect disabled\n");
1531 return 1;
1532 }
1533 if (is_smb3) {
1534 cifs_dbg(VFS, "vers=2.0 not permitted when mounting with smb3\n");
1535 return 1;
1536 }
1537 vol->ops = &smb20_operations;
1538 vol->vals = &smb20_values;
1539 break;
1540 #else
1541 case Smb_1:
1542 cifs_dbg(VFS, "vers=1.0 (cifs) mount not permitted when legacy dialects disabled\n");
1543 return 1;
1544 case Smb_20:
1545 cifs_dbg(VFS, "vers=2.0 mount not permitted when legacy dialects disabled\n");
1546 return 1;
1547 #endif /* CIFS_ALLOW_INSECURE_LEGACY */
1548 case Smb_21:
1549 vol->ops = &smb21_operations;
1550 vol->vals = &smb21_values;
1551 break;
1552 case Smb_30:
1553 vol->ops = &smb30_operations;
1554 vol->vals = &smb30_values;
1555 break;
1556 case Smb_302:
1557 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1558 vol->vals = &smb302_values;
1559 break;
1560 case Smb_311:
1561 vol->ops = &smb311_operations;
1562 vol->vals = &smb311_values;
1563 break;
1564 case Smb_3any:
1565 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1566 vol->vals = &smb3any_values;
1567 break;
1568 case Smb_default:
1569 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1570 vol->vals = &smbdefault_values;
1571 break;
1572 default:
1573 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1574 return 1;
1575 }
1576 return 0;
1577 }
1578
1579 /*
1580 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1581 * fields with the result. Returns 0 on success and an error otherwise.
1582 */
1583 static int
1584 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1585 {
1586 char *pos;
1587 const char *delims = "/\\";
1588 size_t len;
1589
1590 if (unlikely(!devname || !*devname)) {
1591 cifs_dbg(VFS, "Device name not specified.\n");
1592 return -EINVAL;
1593 }
1594
1595 /* make sure we have a valid UNC double delimiter prefix */
1596 len = strspn(devname, delims);
1597 if (len != 2)
1598 return -EINVAL;
1599
1600 /* find delimiter between host and sharename */
1601 pos = strpbrk(devname + 2, delims);
1602 if (!pos)
1603 return -EINVAL;
1604
1605 /* skip past delimiter */
1606 ++pos;
1607
1608 /* now go until next delimiter or end of string */
1609 len = strcspn(pos, delims);
1610
1611 /* move "pos" up to delimiter or NULL */
1612 pos += len;
1613 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1614 if (!vol->UNC)
1615 return -ENOMEM;
1616
1617 convert_delimiter(vol->UNC, '\\');
1618
1619 /* skip any delimiter */
1620 if (*pos == '/' || *pos == '\\')
1621 pos++;
1622
1623 /* If pos is NULL then no prepath */
1624 if (!*pos)
1625 return 0;
1626
1627 vol->prepath = kstrdup(pos, GFP_KERNEL);
1628 if (!vol->prepath)
1629 return -ENOMEM;
1630
1631 return 0;
1632 }
1633
1634 static int
1635 cifs_parse_mount_options(const char *mountdata, const char *devname,
1636 struct smb_vol *vol, bool is_smb3)
1637 {
1638 char *data, *end;
1639 char *mountdata_copy = NULL, *options;
1640 unsigned int temp_len, i, j;
1641 char separator[2];
1642 short int override_uid = -1;
1643 short int override_gid = -1;
1644 bool uid_specified = false;
1645 bool gid_specified = false;
1646 bool sloppy = false;
1647 char *invalid = NULL;
1648 char *nodename = utsname()->nodename;
1649 char *string = NULL;
1650 char *tmp_end, *value;
1651 char delim;
1652 bool got_ip = false;
1653 bool got_version = false;
1654 unsigned short port = 0;
1655 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1656
1657 separator[0] = ',';
1658 separator[1] = 0;
1659 delim = separator[0];
1660
1661 /* ensure we always start with zeroed-out smb_vol */
1662 memset(vol, 0, sizeof(*vol));
1663
1664 /*
1665 * does not have to be perfect mapping since field is
1666 * informational, only used for servers that do not support
1667 * port 445 and it can be overridden at mount time
1668 */
1669 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1670 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1671 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1672
1673 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1674 /* null target name indicates to use *SMBSERVR default called name
1675 if we end up sending RFC1001 session initialize */
1676 vol->target_rfc1001_name[0] = 0;
1677 vol->cred_uid = current_uid();
1678 vol->linux_uid = current_uid();
1679 vol->linux_gid = current_gid();
1680 vol->bsize = 1024 * 1024; /* can improve cp performance significantly */
1681 /*
1682 * default to SFM style remapping of seven reserved characters
1683 * unless user overrides it or we negotiate CIFS POSIX where
1684 * it is unnecessary. Can not simultaneously use more than one mapping
1685 * since then readdir could list files that open could not open
1686 */
1687 vol->remap = true;
1688
1689 /* default to only allowing write access to owner of the mount */
1690 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1691
1692 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1693 /* default is always to request posix paths. */
1694 vol->posix_paths = 1;
1695 /* default to using server inode numbers where available */
1696 vol->server_ino = 1;
1697
1698 /* default is to use strict cifs caching semantics */
1699 vol->strict_io = true;
1700
1701 vol->actimeo = CIFS_DEF_ACTIMEO;
1702
1703 /* Most clients set timeout to 0, allows server to use its default */
1704 vol->handle_timeout = 0; /* See MS-SMB2 spec section 2.2.14.2.12 */
1705
1706 /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1707 vol->ops = &smb30_operations;
1708 vol->vals = &smbdefault_values;
1709
1710 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1711
1712 /* default to no multichannel (single server connection) */
1713 vol->multichannel = false;
1714 vol->max_channels = 1;
1715
1716 if (!mountdata)
1717 goto cifs_parse_mount_err;
1718
1719 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1720 if (!mountdata_copy)
1721 goto cifs_parse_mount_err;
1722
1723 options = mountdata_copy;
1724 end = options + strlen(options);
1725
1726 if (strncmp(options, "sep=", 4) == 0) {
1727 if (options[4] != 0) {
1728 separator[0] = options[4];
1729 options += 5;
1730 } else {
1731 cifs_dbg(FYI, "Null separator not allowed\n");
1732 }
1733 }
1734 vol->backupuid_specified = false; /* no backup intent for a user */
1735 vol->backupgid_specified = false; /* no backup intent for a group */
1736
1737 switch (cifs_parse_devname(devname, vol)) {
1738 case 0:
1739 break;
1740 case -ENOMEM:
1741 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1742 goto cifs_parse_mount_err;
1743 case -EINVAL:
1744 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1745 goto cifs_parse_mount_err;
1746 default:
1747 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1748 goto cifs_parse_mount_err;
1749 }
1750
1751 while ((data = strsep(&options, separator)) != NULL) {
1752 substring_t args[MAX_OPT_ARGS];
1753 unsigned long option;
1754 int token;
1755
1756 if (!*data)
1757 continue;
1758
1759 token = match_token(data, cifs_mount_option_tokens, args);
1760
1761 switch (token) {
1762
1763 /* Ingnore the following */
1764 case Opt_ignore:
1765 break;
1766
1767 /* Boolean values */
1768 case Opt_user_xattr:
1769 vol->no_xattr = 0;
1770 break;
1771 case Opt_nouser_xattr:
1772 vol->no_xattr = 1;
1773 break;
1774 case Opt_forceuid:
1775 override_uid = 1;
1776 break;
1777 case Opt_noforceuid:
1778 override_uid = 0;
1779 break;
1780 case Opt_forcegid:
1781 override_gid = 1;
1782 break;
1783 case Opt_noforcegid:
1784 override_gid = 0;
1785 break;
1786 case Opt_noblocksend:
1787 vol->noblocksnd = 1;
1788 break;
1789 case Opt_noautotune:
1790 vol->noautotune = 1;
1791 break;
1792 case Opt_nolease:
1793 vol->no_lease = 1;
1794 break;
1795 case Opt_hard:
1796 vol->retry = 1;
1797 break;
1798 case Opt_soft:
1799 vol->retry = 0;
1800 break;
1801 case Opt_perm:
1802 vol->noperm = 0;
1803 break;
1804 case Opt_noperm:
1805 vol->noperm = 1;
1806 break;
1807 case Opt_mapchars:
1808 vol->sfu_remap = true;
1809 vol->remap = false; /* disable SFM mapping */
1810 break;
1811 case Opt_nomapchars:
1812 vol->sfu_remap = false;
1813 break;
1814 case Opt_mapposix:
1815 vol->remap = true;
1816 vol->sfu_remap = false; /* disable SFU mapping */
1817 break;
1818 case Opt_nomapposix:
1819 vol->remap = false;
1820 break;
1821 case Opt_sfu:
1822 vol->sfu_emul = 1;
1823 break;
1824 case Opt_nosfu:
1825 vol->sfu_emul = 0;
1826 break;
1827 case Opt_nodfs:
1828 vol->nodfs = 1;
1829 break;
1830 case Opt_rootfs:
1831 #ifdef CONFIG_CIFS_ROOT
1832 vol->rootfs = true;
1833 #endif
1834 break;
1835 case Opt_posixpaths:
1836 vol->posix_paths = 1;
1837 break;
1838 case Opt_noposixpaths:
1839 vol->posix_paths = 0;
1840 break;
1841 case Opt_nounix:
1842 if (vol->linux_ext)
1843 cifs_dbg(VFS,
1844 "conflicting unix mount options\n");
1845 vol->no_linux_ext = 1;
1846 break;
1847 case Opt_unix:
1848 if (vol->no_linux_ext)
1849 cifs_dbg(VFS,
1850 "conflicting unix mount options\n");
1851 vol->linux_ext = 1;
1852 break;
1853 case Opt_nocase:
1854 vol->nocase = 1;
1855 break;
1856 case Opt_brl:
1857 vol->nobrl = 0;
1858 break;
1859 case Opt_nobrl:
1860 vol->nobrl = 1;
1861 /*
1862 * turn off mandatory locking in mode
1863 * if remote locking is turned off since the
1864 * local vfs will do advisory
1865 */
1866 if (vol->file_mode ==
1867 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1868 vol->file_mode = S_IALLUGO;
1869 break;
1870 case Opt_nohandlecache:
1871 vol->nohandlecache = 1;
1872 break;
1873 case Opt_handlecache:
1874 vol->nohandlecache = 0;
1875 break;
1876 case Opt_forcemandatorylock:
1877 vol->mand_lock = 1;
1878 break;
1879 case Opt_setuids:
1880 vol->setuids = 1;
1881 break;
1882 case Opt_nosetuids:
1883 vol->setuids = 0;
1884 break;
1885 case Opt_setuidfromacl:
1886 vol->setuidfromacl = 1;
1887 break;
1888 case Opt_dynperm:
1889 vol->dynperm = true;
1890 break;
1891 case Opt_nodynperm:
1892 vol->dynperm = false;
1893 break;
1894 case Opt_nohard:
1895 vol->retry = 0;
1896 break;
1897 case Opt_nosoft:
1898 vol->retry = 1;
1899 break;
1900 case Opt_nointr:
1901 vol->intr = 0;
1902 break;
1903 case Opt_intr:
1904 vol->intr = 1;
1905 break;
1906 case Opt_nostrictsync:
1907 vol->nostrictsync = 1;
1908 break;
1909 case Opt_strictsync:
1910 vol->nostrictsync = 0;
1911 break;
1912 case Opt_serverino:
1913 vol->server_ino = 1;
1914 break;
1915 case Opt_noserverino:
1916 vol->server_ino = 0;
1917 break;
1918 case Opt_rwpidforward:
1919 vol->rwpidforward = 1;
1920 break;
1921 case Opt_modesid:
1922 vol->mode_ace = 1;
1923 break;
1924 case Opt_cifsacl:
1925 vol->cifs_acl = 1;
1926 break;
1927 case Opt_nocifsacl:
1928 vol->cifs_acl = 0;
1929 break;
1930 case Opt_acl:
1931 vol->no_psx_acl = 0;
1932 break;
1933 case Opt_noacl:
1934 vol->no_psx_acl = 1;
1935 break;
1936 case Opt_locallease:
1937 vol->local_lease = 1;
1938 break;
1939 case Opt_sign:
1940 vol->sign = true;
1941 break;
1942 case Opt_ignore_signature:
1943 vol->sign = true;
1944 vol->ignore_signature = true;
1945 break;
1946 case Opt_seal:
1947 /* we do not do the following in secFlags because seal
1948 * is a per tree connection (mount) not a per socket
1949 * or per-smb connection option in the protocol
1950 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1951 */
1952 vol->seal = 1;
1953 break;
1954 case Opt_noac:
1955 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1956 break;
1957 case Opt_fsc:
1958 #ifndef CONFIG_CIFS_FSCACHE
1959 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1960 goto cifs_parse_mount_err;
1961 #endif
1962 vol->fsc = true;
1963 break;
1964 case Opt_mfsymlinks:
1965 vol->mfsymlinks = true;
1966 break;
1967 case Opt_multiuser:
1968 vol->multiuser = true;
1969 break;
1970 case Opt_sloppy:
1971 sloppy = true;
1972 break;
1973 case Opt_nosharesock:
1974 vol->nosharesock = true;
1975 break;
1976 case Opt_nopersistent:
1977 vol->nopersistent = true;
1978 if (vol->persistent) {
1979 cifs_dbg(VFS,
1980 "persistenthandles mount options conflict\n");
1981 goto cifs_parse_mount_err;
1982 }
1983 break;
1984 case Opt_persistent:
1985 vol->persistent = true;
1986 if ((vol->nopersistent) || (vol->resilient)) {
1987 cifs_dbg(VFS,
1988 "persistenthandles mount options conflict\n");
1989 goto cifs_parse_mount_err;
1990 }
1991 break;
1992 case Opt_resilient:
1993 vol->resilient = true;
1994 if (vol->persistent) {
1995 cifs_dbg(VFS,
1996 "persistenthandles mount options conflict\n");
1997 goto cifs_parse_mount_err;
1998 }
1999 break;
2000 case Opt_noresilient:
2001 vol->resilient = false; /* already the default */
2002 break;
2003 case Opt_domainauto:
2004 vol->domainauto = true;
2005 break;
2006 case Opt_rdma:
2007 vol->rdma = true;
2008 break;
2009 case Opt_multichannel:
2010 vol->multichannel = true;
2011 break;
2012 case Opt_nomultichannel:
2013 vol->multichannel = false;
2014 break;
2015 case Opt_compress:
2016 vol->compression = UNKNOWN_TYPE;
2017 cifs_dbg(VFS,
2018 "SMB3 compression support is experimental\n");
2019 break;
2020
2021 /* Numeric Values */
2022 case Opt_backupuid:
2023 if (get_option_uid(args, &vol->backupuid)) {
2024 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
2025 __func__);
2026 goto cifs_parse_mount_err;
2027 }
2028 vol->backupuid_specified = true;
2029 break;
2030 case Opt_backupgid:
2031 if (get_option_gid(args, &vol->backupgid)) {
2032 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
2033 __func__);
2034 goto cifs_parse_mount_err;
2035 }
2036 vol->backupgid_specified = true;
2037 break;
2038 case Opt_uid:
2039 if (get_option_uid(args, &vol->linux_uid)) {
2040 cifs_dbg(VFS, "%s: Invalid uid value\n",
2041 __func__);
2042 goto cifs_parse_mount_err;
2043 }
2044 uid_specified = true;
2045 break;
2046 case Opt_cruid:
2047 if (get_option_uid(args, &vol->cred_uid)) {
2048 cifs_dbg(VFS, "%s: Invalid cruid value\n",
2049 __func__);
2050 goto cifs_parse_mount_err;
2051 }
2052 break;
2053 case Opt_gid:
2054 if (get_option_gid(args, &vol->linux_gid)) {
2055 cifs_dbg(VFS, "%s: Invalid gid value\n",
2056 __func__);
2057 goto cifs_parse_mount_err;
2058 }
2059 gid_specified = true;
2060 break;
2061 case Opt_file_mode:
2062 if (get_option_ul(args, &option)) {
2063 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
2064 __func__);
2065 goto cifs_parse_mount_err;
2066 }
2067 vol->file_mode = option;
2068 break;
2069 case Opt_dirmode:
2070 if (get_option_ul(args, &option)) {
2071 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
2072 __func__);
2073 goto cifs_parse_mount_err;
2074 }
2075 vol->dir_mode = option;
2076 break;
2077 case Opt_port:
2078 if (get_option_ul(args, &option) ||
2079 option > USHRT_MAX) {
2080 cifs_dbg(VFS, "%s: Invalid port value\n",
2081 __func__);
2082 goto cifs_parse_mount_err;
2083 }
2084 port = (unsigned short)option;
2085 break;
2086 case Opt_min_enc_offload:
2087 if (get_option_ul(args, &option)) {
2088 cifs_dbg(VFS, "Invalid minimum encrypted read offload size (esize)\n");
2089 goto cifs_parse_mount_err;
2090 }
2091 vol->min_offload = option;
2092 break;
2093 case Opt_blocksize:
2094 if (get_option_ul(args, &option)) {
2095 cifs_dbg(VFS, "%s: Invalid blocksize value\n",
2096 __func__);
2097 goto cifs_parse_mount_err;
2098 }
2099 /*
2100 * inode blocksize realistically should never need to be
2101 * less than 16K or greater than 16M and default is 1MB.
2102 * Note that small inode block sizes (e.g. 64K) can lead
2103 * to very poor performance of common tools like cp and scp
2104 */
2105 if ((option < CIFS_MAX_MSGSIZE) ||
2106 (option > (4 * SMB3_DEFAULT_IOSIZE))) {
2107 cifs_dbg(VFS, "%s: Invalid blocksize\n",
2108 __func__);
2109 goto cifs_parse_mount_err;
2110 }
2111 vol->bsize = option;
2112 break;
2113 case Opt_rsize:
2114 if (get_option_ul(args, &option)) {
2115 cifs_dbg(VFS, "%s: Invalid rsize value\n",
2116 __func__);
2117 goto cifs_parse_mount_err;
2118 }
2119 vol->rsize = option;
2120 break;
2121 case Opt_wsize:
2122 if (get_option_ul(args, &option)) {
2123 cifs_dbg(VFS, "%s: Invalid wsize value\n",
2124 __func__);
2125 goto cifs_parse_mount_err;
2126 }
2127 vol->wsize = option;
2128 break;
2129 case Opt_actimeo:
2130 if (get_option_ul(args, &option)) {
2131 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
2132 __func__);
2133 goto cifs_parse_mount_err;
2134 }
2135 vol->actimeo = HZ * option;
2136 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
2137 cifs_dbg(VFS, "attribute cache timeout too large\n");
2138 goto cifs_parse_mount_err;
2139 }
2140 break;
2141 case Opt_handletimeout:
2142 if (get_option_ul(args, &option)) {
2143 cifs_dbg(VFS, "%s: Invalid handletimeout value\n",
2144 __func__);
2145 goto cifs_parse_mount_err;
2146 }
2147 vol->handle_timeout = option;
2148 if (vol->handle_timeout > SMB3_MAX_HANDLE_TIMEOUT) {
2149 cifs_dbg(VFS, "Invalid handle cache timeout, longer than 16 minutes\n");
2150 goto cifs_parse_mount_err;
2151 }
2152 break;
2153 case Opt_echo_interval:
2154 if (get_option_ul(args, &option)) {
2155 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
2156 __func__);
2157 goto cifs_parse_mount_err;
2158 }
2159 vol->echo_interval = option;
2160 break;
2161 case Opt_snapshot:
2162 if (get_option_ul(args, &option)) {
2163 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
2164 __func__);
2165 goto cifs_parse_mount_err;
2166 }
2167 vol->snapshot_time = option;
2168 break;
2169 case Opt_max_credits:
2170 if (get_option_ul(args, &option) || (option < 20) ||
2171 (option > 60000)) {
2172 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
2173 __func__);
2174 goto cifs_parse_mount_err;
2175 }
2176 vol->max_credits = option;
2177 break;
2178 case Opt_max_channels:
2179 if (get_option_ul(args, &option) || option < 1 ||
2180 option > CIFS_MAX_CHANNELS) {
2181 cifs_dbg(VFS, "%s: Invalid max_channels value, needs to be 1-%d\n",
2182 __func__, CIFS_MAX_CHANNELS);
2183 goto cifs_parse_mount_err;
2184 }
2185 vol->max_channels = option;
2186 break;
2187
2188 /* String Arguments */
2189
2190 case Opt_blank_user:
2191 /* null user, ie. anonymous authentication */
2192 vol->nullauth = 1;
2193 vol->username = NULL;
2194 break;
2195 case Opt_user:
2196 string = match_strdup(args);
2197 if (string == NULL)
2198 goto out_nomem;
2199
2200 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
2201 CIFS_MAX_USERNAME_LEN) {
2202 pr_warn("CIFS: username too long\n");
2203 goto cifs_parse_mount_err;
2204 }
2205
2206 kfree(vol->username);
2207 vol->username = kstrdup(string, GFP_KERNEL);
2208 if (!vol->username)
2209 goto cifs_parse_mount_err;
2210 break;
2211 case Opt_blank_pass:
2212 /* passwords have to be handled differently
2213 * to allow the character used for deliminator
2214 * to be passed within them
2215 */
2216
2217 /*
2218 * Check if this is a case where the password
2219 * starts with a delimiter
2220 */
2221 tmp_end = strchr(data, '=');
2222 tmp_end++;
2223 if (!(tmp_end < end && tmp_end[1] == delim)) {
2224 /* No it is not. Set the password to NULL */
2225 kzfree(vol->password);
2226 vol->password = NULL;
2227 break;
2228 }
2229 /* Fallthrough - to Opt_pass below.*/
2230 case Opt_pass:
2231 /* Obtain the value string */
2232 value = strchr(data, '=');
2233 value++;
2234
2235 /* Set tmp_end to end of the string */
2236 tmp_end = (char *) value + strlen(value);
2237
2238 /* Check if following character is the deliminator
2239 * If yes, we have encountered a double deliminator
2240 * reset the NULL character to the deliminator
2241 */
2242 if (tmp_end < end && tmp_end[1] == delim) {
2243 tmp_end[0] = delim;
2244
2245 /* Keep iterating until we get to a single
2246 * deliminator OR the end
2247 */
2248 while ((tmp_end = strchr(tmp_end, delim))
2249 != NULL && (tmp_end[1] == delim)) {
2250 tmp_end = (char *) &tmp_end[2];
2251 }
2252
2253 /* Reset var options to point to next element */
2254 if (tmp_end) {
2255 tmp_end[0] = '\0';
2256 options = (char *) &tmp_end[1];
2257 } else
2258 /* Reached the end of the mount option
2259 * string */
2260 options = end;
2261 }
2262
2263 kzfree(vol->password);
2264 /* Now build new password string */
2265 temp_len = strlen(value);
2266 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
2267 if (vol->password == NULL) {
2268 pr_warn("CIFS: no memory for password\n");
2269 goto cifs_parse_mount_err;
2270 }
2271
2272 for (i = 0, j = 0; i < temp_len; i++, j++) {
2273 vol->password[j] = value[i];
2274 if ((value[i] == delim) &&
2275 value[i+1] == delim)
2276 /* skip the second deliminator */
2277 i++;
2278 }
2279 vol->password[j] = '\0';
2280 break;
2281 case Opt_blank_ip:
2282 /* FIXME: should this be an error instead? */
2283 got_ip = false;
2284 break;
2285 case Opt_ip:
2286 string = match_strdup(args);
2287 if (string == NULL)
2288 goto out_nomem;
2289
2290 if (!cifs_convert_address(dstaddr, string,
2291 strlen(string))) {
2292 pr_err("CIFS: bad ip= option (%s).\n", string);
2293 goto cifs_parse_mount_err;
2294 }
2295 got_ip = true;
2296 break;
2297 case Opt_domain:
2298 string = match_strdup(args);
2299 if (string == NULL)
2300 goto out_nomem;
2301
2302 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
2303 == CIFS_MAX_DOMAINNAME_LEN) {
2304 pr_warn("CIFS: domain name too long\n");
2305 goto cifs_parse_mount_err;
2306 }
2307
2308 kfree(vol->domainname);
2309 vol->domainname = kstrdup(string, GFP_KERNEL);
2310 if (!vol->domainname) {
2311 pr_warn("CIFS: no memory for domainname\n");
2312 goto cifs_parse_mount_err;
2313 }
2314 cifs_dbg(FYI, "Domain name set\n");
2315 break;
2316 case Opt_srcaddr:
2317 string = match_strdup(args);
2318 if (string == NULL)
2319 goto out_nomem;
2320
2321 if (!cifs_convert_address(
2322 (struct sockaddr *)&vol->srcaddr,
2323 string, strlen(string))) {
2324 pr_warn("CIFS: Could not parse srcaddr: %s\n",
2325 string);
2326 goto cifs_parse_mount_err;
2327 }
2328 break;
2329 case Opt_iocharset:
2330 string = match_strdup(args);
2331 if (string == NULL)
2332 goto out_nomem;
2333
2334 if (strnlen(string, 1024) >= 65) {
2335 pr_warn("CIFS: iocharset name too long.\n");
2336 goto cifs_parse_mount_err;
2337 }
2338
2339 if (strncasecmp(string, "default", 7) != 0) {
2340 kfree(vol->iocharset);
2341 vol->iocharset = kstrdup(string,
2342 GFP_KERNEL);
2343 if (!vol->iocharset) {
2344 pr_warn("CIFS: no memory for charset\n");
2345 goto cifs_parse_mount_err;
2346 }
2347 }
2348 /* if iocharset not set then load_nls_default
2349 * is used by caller
2350 */
2351 cifs_dbg(FYI, "iocharset set to %s\n", string);
2352 break;
2353 case Opt_netbiosname:
2354 string = match_strdup(args);
2355 if (string == NULL)
2356 goto out_nomem;
2357
2358 memset(vol->source_rfc1001_name, 0x20,
2359 RFC1001_NAME_LEN);
2360 /*
2361 * FIXME: are there cases in which a comma can
2362 * be valid in workstation netbios name (and
2363 * need special handling)?
2364 */
2365 for (i = 0; i < RFC1001_NAME_LEN; i++) {
2366 /* don't ucase netbiosname for user */
2367 if (string[i] == 0)
2368 break;
2369 vol->source_rfc1001_name[i] = string[i];
2370 }
2371 /* The string has 16th byte zero still from
2372 * set at top of the function
2373 */
2374 if (i == RFC1001_NAME_LEN && string[i] != 0)
2375 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
2376 break;
2377 case Opt_servern:
2378 /* servernetbiosname specified override *SMBSERVER */
2379 string = match_strdup(args);
2380 if (string == NULL)
2381 goto out_nomem;
2382
2383 /* last byte, type, is 0x20 for servr type */
2384 memset(vol->target_rfc1001_name, 0x20,
2385 RFC1001_NAME_LEN_WITH_NULL);
2386
2387 /* BB are there cases in which a comma can be
2388 valid in this workstation netbios name
2389 (and need special handling)? */
2390
2391 /* user or mount helper must uppercase the
2392 netbios name */
2393 for (i = 0; i < 15; i++) {
2394 if (string[i] == 0)
2395 break;
2396 vol->target_rfc1001_name[i] = string[i];
2397 }
2398 /* The string has 16th byte zero still from
2399 set at top of the function */
2400 if (i == RFC1001_NAME_LEN && string[i] != 0)
2401 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
2402 break;
2403 case Opt_ver:
2404 /* version of mount userspace tools, not dialect */
2405 string = match_strdup(args);
2406 if (string == NULL)
2407 goto out_nomem;
2408
2409 /* If interface changes in mount.cifs bump to new ver */
2410 if (strncasecmp(string, "1", 1) == 0) {
2411 if (strlen(string) > 1) {
2412 pr_warn("Bad mount helper ver=%s. Did "
2413 "you want SMB1 (CIFS) dialect "
2414 "and mean to type vers=1.0 "
2415 "instead?\n", string);
2416 goto cifs_parse_mount_err;
2417 }
2418 /* This is the default */
2419 break;
2420 }
2421 /* For all other value, error */
2422 pr_warn("CIFS: Invalid mount helper version specified\n");
2423 goto cifs_parse_mount_err;
2424 case Opt_vers:
2425 /* protocol version (dialect) */
2426 string = match_strdup(args);
2427 if (string == NULL)
2428 goto out_nomem;
2429
2430 if (cifs_parse_smb_version(string, vol, is_smb3) != 0)
2431 goto cifs_parse_mount_err;
2432 got_version = true;
2433 break;
2434 case Opt_sec:
2435 string = match_strdup(args);
2436 if (string == NULL)
2437 goto out_nomem;
2438
2439 if (cifs_parse_security_flavors(string, vol) != 0)
2440 goto cifs_parse_mount_err;
2441 break;
2442 case Opt_cache:
2443 string = match_strdup(args);
2444 if (string == NULL)
2445 goto out_nomem;
2446
2447 if (cifs_parse_cache_flavor(string, vol) != 0)
2448 goto cifs_parse_mount_err;
2449 break;
2450 default:
2451 /*
2452 * An option we don't recognize. Save it off for later
2453 * if we haven't already found one
2454 */
2455 if (!invalid)
2456 invalid = data;
2457 break;
2458 }
2459 /* Free up any allocated string */
2460 kfree(string);
2461 string = NULL;
2462 }
2463
2464 if (!sloppy && invalid) {
2465 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
2466 goto cifs_parse_mount_err;
2467 }
2468
2469 if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
2470 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
2471 goto cifs_parse_mount_err;
2472 }
2473
2474 #ifndef CONFIG_KEYS
2475 /* Muliuser mounts require CONFIG_KEYS support */
2476 if (vol->multiuser) {
2477 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
2478 goto cifs_parse_mount_err;
2479 }
2480 #endif
2481 if (!vol->UNC) {
2482 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
2483 goto cifs_parse_mount_err;
2484 }
2485
2486 /* make sure UNC has a share name */
2487 if (!strchr(vol->UNC + 3, '\\')) {
2488 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
2489 goto cifs_parse_mount_err;
2490 }
2491
2492 if (!got_ip) {
2493 int len;
2494 const char *slash;
2495
2496 /* No ip= option specified? Try to get it from UNC */
2497 /* Use the address part of the UNC. */
2498 slash = strchr(&vol->UNC[2], '\\');
2499 len = slash - &vol->UNC[2];
2500 if (!cifs_convert_address(dstaddr, &vol->UNC[2], len)) {
2501 pr_err("Unable to determine destination address.\n");
2502 goto cifs_parse_mount_err;
2503 }
2504 }
2505
2506 /* set the port that we got earlier */
2507 cifs_set_port(dstaddr, port);
2508
2509 if (uid_specified)
2510 vol->override_uid = override_uid;
2511 else if (override_uid == 1)
2512 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
2513
2514 if (gid_specified)
2515 vol->override_gid = override_gid;
2516 else if (override_gid == 1)
2517 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
2518
2519 if (got_version == false)
2520 pr_warn("No dialect specified on mount. Default has changed to "
2521 "a more secure dialect, SMB2.1 or later (e.g. SMB3), from CIFS "
2522 "(SMB1). To use the less secure SMB1 dialect to access "
2523 "old servers which do not support SMB3 (or SMB2.1) specify vers=1.0"
2524 " on mount.\n");
2525
2526 kfree(mountdata_copy);
2527 return 0;
2528
2529 out_nomem:
2530 pr_warn("Could not allocate temporary buffer\n");
2531 cifs_parse_mount_err:
2532 kfree(string);
2533 kfree(mountdata_copy);
2534 return 1;
2535 }
2536
2537 /** Returns true if srcaddr isn't specified and rhs isn't
2538 * specified, or if srcaddr is specified and
2539 * matches the IP address of the rhs argument.
2540 */
2541 static bool
2542 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
2543 {
2544 switch (srcaddr->sa_family) {
2545 case AF_UNSPEC:
2546 return (rhs->sa_family == AF_UNSPEC);
2547 case AF_INET: {
2548 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
2549 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
2550 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2551 }
2552 case AF_INET6: {
2553 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2554 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
2555 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2556 }
2557 default:
2558 WARN_ON(1);
2559 return false; /* don't expect to be here */
2560 }
2561 }
2562
2563 /*
2564 * If no port is specified in addr structure, we try to match with 445 port
2565 * and if it fails - with 139 ports. It should be called only if address
2566 * families of server and addr are equal.
2567 */
2568 static bool
2569 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2570 {
2571 __be16 port, *sport;
2572
2573 /* SMBDirect manages its own ports, don't match it here */
2574 if (server->rdma)
2575 return true;
2576
2577 switch (addr->sa_family) {
2578 case AF_INET:
2579 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2580 port = ((struct sockaddr_in *) addr)->sin_port;
2581 break;
2582 case AF_INET6:
2583 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2584 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2585 break;
2586 default:
2587 WARN_ON(1);
2588 return false;
2589 }
2590
2591 if (!port) {
2592 port = htons(CIFS_PORT);
2593 if (port == *sport)
2594 return true;
2595
2596 port = htons(RFC1001_PORT);
2597 }
2598
2599 return port == *sport;
2600 }
2601
2602 static bool
2603 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2604 struct sockaddr *srcaddr)
2605 {
2606 switch (addr->sa_family) {
2607 case AF_INET: {
2608 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2609 struct sockaddr_in *srv_addr4 =
2610 (struct sockaddr_in *)&server->dstaddr;
2611
2612 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2613 return false;
2614 break;
2615 }
2616 case AF_INET6: {
2617 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2618 struct sockaddr_in6 *srv_addr6 =
2619 (struct sockaddr_in6 *)&server->dstaddr;
2620
2621 if (!ipv6_addr_equal(&addr6->sin6_addr,
2622 &srv_addr6->sin6_addr))
2623 return false;
2624 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2625 return false;
2626 break;
2627 }
2628 default:
2629 WARN_ON(1);
2630 return false; /* don't expect to be here */
2631 }
2632
2633 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2634 return false;
2635
2636 return true;
2637 }
2638
2639 static bool
2640 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2641 {
2642 /*
2643 * The select_sectype function should either return the vol->sectype
2644 * that was specified, or "Unspecified" if that sectype was not
2645 * compatible with the given NEGOTIATE request.
2646 */
2647 if (server->ops->select_sectype(server, vol->sectype)
2648 == Unspecified)
2649 return false;
2650
2651 /*
2652 * Now check if signing mode is acceptable. No need to check
2653 * global_secflags at this point since if MUST_SIGN is set then
2654 * the server->sign had better be too.
2655 */
2656 if (vol->sign && !server->sign)
2657 return false;
2658
2659 return true;
2660 }
2661
2662 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2663 {
2664 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2665
2666 if (vol->nosharesock)
2667 return 0;
2668
2669 /* If multidialect negotiation see if existing sessions match one */
2670 if (strcmp(vol->vals->version_string, SMB3ANY_VERSION_STRING) == 0) {
2671 if (server->vals->protocol_id < SMB30_PROT_ID)
2672 return 0;
2673 } else if (strcmp(vol->vals->version_string,
2674 SMBDEFAULT_VERSION_STRING) == 0) {
2675 if (server->vals->protocol_id < SMB21_PROT_ID)
2676 return 0;
2677 } else if ((server->vals != vol->vals) || (server->ops != vol->ops))
2678 return 0;
2679
2680 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2681 return 0;
2682
2683 if (!match_address(server, addr,
2684 (struct sockaddr *)&vol->srcaddr))
2685 return 0;
2686
2687 if (!match_port(server, addr))
2688 return 0;
2689
2690 if (!match_security(server, vol))
2691 return 0;
2692
2693 if (server->echo_interval != vol->echo_interval * HZ)
2694 return 0;
2695
2696 if (server->rdma != vol->rdma)
2697 return 0;
2698
2699 if (server->ignore_signature != vol->ignore_signature)
2700 return 0;
2701
2702 if (server->min_offload != vol->min_offload)
2703 return 0;
2704
2705 return 1;
2706 }
2707
2708 struct TCP_Server_Info *
2709 cifs_find_tcp_session(struct smb_vol *vol)
2710 {
2711 struct TCP_Server_Info *server;
2712
2713 spin_lock(&cifs_tcp_ses_lock);
2714 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2715 /*
2716 * Skip ses channels since they're only handled in lower layers
2717 * (e.g. cifs_send_recv).
2718 */
2719 if (server->is_channel || !match_server(server, vol))
2720 continue;
2721
2722 ++server->srv_count;
2723 spin_unlock(&cifs_tcp_ses_lock);
2724 cifs_dbg(FYI, "Existing tcp session with server found\n");
2725 return server;
2726 }
2727 spin_unlock(&cifs_tcp_ses_lock);
2728 return NULL;
2729 }
2730
2731 void
2732 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2733 {
2734 struct task_struct *task;
2735
2736 spin_lock(&cifs_tcp_ses_lock);
2737 if (--server->srv_count > 0) {
2738 spin_unlock(&cifs_tcp_ses_lock);
2739 return;
2740 }
2741
2742 put_net(cifs_net_ns(server));
2743
2744 list_del_init(&server->tcp_ses_list);
2745 spin_unlock(&cifs_tcp_ses_lock);
2746
2747 cancel_delayed_work_sync(&server->echo);
2748
2749 if (from_reconnect)
2750 /*
2751 * Avoid deadlock here: reconnect work calls
2752 * cifs_put_tcp_session() at its end. Need to be sure
2753 * that reconnect work does nothing with server pointer after
2754 * that step.
2755 */
2756 cancel_delayed_work(&server->reconnect);
2757 else
2758 cancel_delayed_work_sync(&server->reconnect);
2759
2760 spin_lock(&GlobalMid_Lock);
2761 server->tcpStatus = CifsExiting;
2762 spin_unlock(&GlobalMid_Lock);
2763
2764 cifs_crypto_secmech_release(server);
2765 cifs_fscache_release_client_cookie(server);
2766
2767 kfree(server->session_key.response);
2768 server->session_key.response = NULL;
2769 server->session_key.len = 0;
2770
2771 task = xchg(&server->tsk, NULL);
2772 if (task)
2773 send_sig(SIGKILL, task, 1);
2774 }
2775
2776 struct TCP_Server_Info *
2777 cifs_get_tcp_session(struct smb_vol *volume_info)
2778 {
2779 struct TCP_Server_Info *tcp_ses = NULL;
2780 int rc;
2781
2782 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2783
2784 /* see if we already have a matching tcp_ses */
2785 tcp_ses = cifs_find_tcp_session(volume_info);
2786 if (tcp_ses)
2787 return tcp_ses;
2788
2789 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2790 if (!tcp_ses) {
2791 rc = -ENOMEM;
2792 goto out_err;
2793 }
2794
2795 tcp_ses->ops = volume_info->ops;
2796 tcp_ses->vals = volume_info->vals;
2797 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2798 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2799 if (IS_ERR(tcp_ses->hostname)) {
2800 rc = PTR_ERR(tcp_ses->hostname);
2801 goto out_err_crypto_release;
2802 }
2803
2804 tcp_ses->noblockcnt = volume_info->rootfs;
2805 tcp_ses->noblocksnd = volume_info->noblocksnd || volume_info->rootfs;
2806 tcp_ses->noautotune = volume_info->noautotune;
2807 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2808 tcp_ses->rdma = volume_info->rdma;
2809 tcp_ses->in_flight = 0;
2810 tcp_ses->max_in_flight = 0;
2811 tcp_ses->credits = 1;
2812 init_waitqueue_head(&tcp_ses->response_q);
2813 init_waitqueue_head(&tcp_ses->request_q);
2814 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2815 mutex_init(&tcp_ses->srv_mutex);
2816 memcpy(tcp_ses->workstation_RFC1001_name,
2817 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2818 memcpy(tcp_ses->server_RFC1001_name,
2819 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2820 tcp_ses->session_estab = false;
2821 tcp_ses->sequence_number = 0;
2822 tcp_ses->reconnect_instance = 1;
2823 tcp_ses->lstrp = jiffies;
2824 tcp_ses->compress_algorithm = cpu_to_le16(volume_info->compression);
2825 spin_lock_init(&tcp_ses->req_lock);
2826 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2827 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2828 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2829 INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2830 mutex_init(&tcp_ses->reconnect_mutex);
2831 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2832 sizeof(tcp_ses->srcaddr));
2833 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2834 sizeof(tcp_ses->dstaddr));
2835 if (volume_info->use_client_guid)
2836 memcpy(tcp_ses->client_guid, volume_info->client_guid,
2837 SMB2_CLIENT_GUID_SIZE);
2838 else
2839 generate_random_uuid(tcp_ses->client_guid);
2840 /*
2841 * at this point we are the only ones with the pointer
2842 * to the struct since the kernel thread not created yet
2843 * no need to spinlock this init of tcpStatus or srv_count
2844 */
2845 tcp_ses->tcpStatus = CifsNew;
2846 ++tcp_ses->srv_count;
2847
2848 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2849 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2850 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2851 else
2852 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2853 if (tcp_ses->rdma) {
2854 #ifndef CONFIG_CIFS_SMB_DIRECT
2855 cifs_dbg(VFS, "CONFIG_CIFS_SMB_DIRECT is not enabled\n");
2856 rc = -ENOENT;
2857 goto out_err_crypto_release;
2858 #endif
2859 tcp_ses->smbd_conn = smbd_get_connection(
2860 tcp_ses, (struct sockaddr *)&volume_info->dstaddr);
2861 if (tcp_ses->smbd_conn) {
2862 cifs_dbg(VFS, "RDMA transport established\n");
2863 rc = 0;
2864 goto smbd_connected;
2865 } else {
2866 rc = -ENOENT;
2867 goto out_err_crypto_release;
2868 }
2869 }
2870 rc = ip_connect(tcp_ses);
2871 if (rc < 0) {
2872 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2873 goto out_err_crypto_release;
2874 }
2875 smbd_connected:
2876 /*
2877 * since we're in a cifs function already, we know that
2878 * this will succeed. No need for try_module_get().
2879 */
2880 __module_get(THIS_MODULE);
2881 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2882 tcp_ses, "cifsd");
2883 if (IS_ERR(tcp_ses->tsk)) {
2884 rc = PTR_ERR(tcp_ses->tsk);
2885 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2886 module_put(THIS_MODULE);
2887 goto out_err_crypto_release;
2888 }
2889 tcp_ses->min_offload = volume_info->min_offload;
2890 tcp_ses->tcpStatus = CifsNeedNegotiate;
2891
2892 tcp_ses->nr_targets = 1;
2893 tcp_ses->ignore_signature = volume_info->ignore_signature;
2894 /* thread spawned, put it on the list */
2895 spin_lock(&cifs_tcp_ses_lock);
2896 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2897 spin_unlock(&cifs_tcp_ses_lock);
2898
2899 cifs_fscache_get_client_cookie(tcp_ses);
2900
2901 /* queue echo request delayed work */
2902 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2903
2904 return tcp_ses;
2905
2906 out_err_crypto_release:
2907 cifs_crypto_secmech_release(tcp_ses);
2908
2909 put_net(cifs_net_ns(tcp_ses));
2910
2911 out_err:
2912 if (tcp_ses) {
2913 if (!IS_ERR(tcp_ses->hostname))
2914 kfree(tcp_ses->hostname);
2915 if (tcp_ses->ssocket)
2916 sock_release(tcp_ses->ssocket);
2917 kfree(tcp_ses);
2918 }
2919 return ERR_PTR(rc);
2920 }
2921
2922 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2923 {
2924 if (vol->sectype != Unspecified &&
2925 vol->sectype != ses->sectype)
2926 return 0;
2927
2928 /*
2929 * If an existing session is limited to less channels than
2930 * requested, it should not be reused
2931 */
2932 if (ses->chan_max < vol->max_channels)
2933 return 0;
2934
2935 switch (ses->sectype) {
2936 case Kerberos:
2937 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2938 return 0;
2939 break;
2940 default:
2941 /* NULL username means anonymous session */
2942 if (ses->user_name == NULL) {
2943 if (!vol->nullauth)
2944 return 0;
2945 break;
2946 }
2947
2948 /* anything else takes username/password */
2949 if (strncmp(ses->user_name,
2950 vol->username ? vol->username : "",
2951 CIFS_MAX_USERNAME_LEN))
2952 return 0;
2953 if ((vol->username && strlen(vol->username) != 0) &&
2954 ses->password != NULL &&
2955 strncmp(ses->password,
2956 vol->password ? vol->password : "",
2957 CIFS_MAX_PASSWORD_LEN))
2958 return 0;
2959 }
2960 return 1;
2961 }
2962
2963 /**
2964 * cifs_setup_ipc - helper to setup the IPC tcon for the session
2965 *
2966 * A new IPC connection is made and stored in the session
2967 * tcon_ipc. The IPC tcon has the same lifetime as the session.
2968 */
2969 static int
2970 cifs_setup_ipc(struct cifs_ses *ses, struct smb_vol *volume_info)
2971 {
2972 int rc = 0, xid;
2973 struct cifs_tcon *tcon;
2974 struct nls_table *nls_codepage;
2975 char unc[SERVER_NAME_LENGTH + sizeof("//x/IPC$")] = {0};
2976 bool seal = false;
2977 struct TCP_Server_Info *server = ses->server;
2978
2979 /*
2980 * If the mount request that resulted in the creation of the
2981 * session requires encryption, force IPC to be encrypted too.
2982 */
2983 if (volume_info->seal) {
2984 if (server->capabilities & SMB2_GLOBAL_CAP_ENCRYPTION)
2985 seal = true;
2986 else {
2987 cifs_server_dbg(VFS,
2988 "IPC: server doesn't support encryption\n");
2989 return -EOPNOTSUPP;
2990 }
2991 }
2992
2993 tcon = tconInfoAlloc();
2994 if (tcon == NULL)
2995 return -ENOMEM;
2996
2997 scnprintf(unc, sizeof(unc), "\\\\%s\\IPC$", server->hostname);
2998
2999 /* cannot fail */
3000 nls_codepage = load_nls_default();
3001
3002 xid = get_xid();
3003 tcon->ses = ses;
3004 tcon->ipc = true;
3005 tcon->seal = seal;
3006 rc = server->ops->tree_connect(xid, ses, unc, tcon, nls_codepage);
3007 free_xid(xid);
3008
3009 if (rc) {
3010 cifs_server_dbg(VFS, "failed to connect to IPC (rc=%d)\n", rc);
3011 tconInfoFree(tcon);
3012 goto out;
3013 }
3014
3015 cifs_dbg(FYI, "IPC tcon rc = %d ipc tid = %d\n", rc, tcon->tid);
3016
3017 ses->tcon_ipc = tcon;
3018 out:
3019 unload_nls(nls_codepage);
3020 return rc;
3021 }
3022
3023 /**
3024 * cifs_free_ipc - helper to release the session IPC tcon
3025 *
3026 * Needs to be called everytime a session is destroyed
3027 */
3028 static int
3029 cifs_free_ipc(struct cifs_ses *ses)
3030 {
3031 int rc = 0, xid;
3032 struct cifs_tcon *tcon = ses->tcon_ipc;
3033
3034 if (tcon == NULL)
3035 return 0;
3036
3037 if (ses->server->ops->tree_disconnect) {
3038 xid = get_xid();
3039 rc = ses->server->ops->tree_disconnect(xid, tcon);
3040 free_xid(xid);
3041 }
3042
3043 if (rc)
3044 cifs_dbg(FYI, "failed to disconnect IPC tcon (rc=%d)\n", rc);
3045
3046 tconInfoFree(tcon);
3047 ses->tcon_ipc = NULL;
3048 return rc;
3049 }
3050
3051 static struct cifs_ses *
3052 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
3053 {
3054 struct cifs_ses *ses;
3055
3056 spin_lock(&cifs_tcp_ses_lock);
3057 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
3058 if (ses->status == CifsExiting)
3059 continue;
3060 if (!match_session(ses, vol))
3061 continue;
3062 ++ses->ses_count;
3063 spin_unlock(&cifs_tcp_ses_lock);
3064 return ses;
3065 }
3066 spin_unlock(&cifs_tcp_ses_lock);
3067 return NULL;
3068 }
3069
3070 void cifs_put_smb_ses(struct cifs_ses *ses)
3071 {
3072 unsigned int rc, xid;
3073 struct TCP_Server_Info *server = ses->server;
3074
3075 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
3076
3077 spin_lock(&cifs_tcp_ses_lock);
3078 if (ses->status == CifsExiting) {
3079 spin_unlock(&cifs_tcp_ses_lock);
3080 return;
3081 }
3082 if (--ses->ses_count > 0) {
3083 spin_unlock(&cifs_tcp_ses_lock);
3084 return;
3085 }
3086 if (ses->status == CifsGood)
3087 ses->status = CifsExiting;
3088 spin_unlock(&cifs_tcp_ses_lock);
3089
3090 cifs_free_ipc(ses);
3091
3092 if (ses->status == CifsExiting && server->ops->logoff) {
3093 xid = get_xid();
3094 rc = server->ops->logoff(xid, ses);
3095 if (rc)
3096 cifs_server_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
3097 __func__, rc);
3098 _free_xid(xid);
3099 }
3100
3101 spin_lock(&cifs_tcp_ses_lock);
3102 list_del_init(&ses->smb_ses_list);
3103 spin_unlock(&cifs_tcp_ses_lock);
3104
3105 /* close any extra channels */
3106 if (ses->chan_count > 1) {
3107 int i;
3108
3109 for (i = 1; i < ses->chan_count; i++)
3110 cifs_put_tcp_session(ses->chans[i].server, 0);
3111 }
3112
3113 sesInfoFree(ses);
3114 cifs_put_tcp_session(server, 0);
3115 }
3116
3117 #ifdef CONFIG_KEYS
3118
3119 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
3120 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
3121
3122 /* Populate username and pw fields from keyring if possible */
3123 static int
3124 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
3125 {
3126 int rc = 0;
3127 int is_domain = 0;
3128 const char *delim, *payload;
3129 char *desc;
3130 ssize_t len;
3131 struct key *key;
3132 struct TCP_Server_Info *server = ses->server;
3133 struct sockaddr_in *sa;
3134 struct sockaddr_in6 *sa6;
3135 const struct user_key_payload *upayload;
3136
3137 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
3138 if (!desc)
3139 return -ENOMEM;
3140
3141 /* try to find an address key first */
3142 switch (server->dstaddr.ss_family) {
3143 case AF_INET:
3144 sa = (struct sockaddr_in *)&server->dstaddr;
3145 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
3146 break;
3147 case AF_INET6:
3148 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
3149 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
3150 break;
3151 default:
3152 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
3153 server->dstaddr.ss_family);
3154 rc = -EINVAL;
3155 goto out_err;
3156 }
3157
3158 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3159 key = request_key(&key_type_logon, desc, "");
3160 if (IS_ERR(key)) {
3161 if (!ses->domainName) {
3162 cifs_dbg(FYI, "domainName is NULL\n");
3163 rc = PTR_ERR(key);
3164 goto out_err;
3165 }
3166
3167 /* didn't work, try to find a domain key */
3168 sprintf(desc, "cifs:d:%s", ses->domainName);
3169 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
3170 key = request_key(&key_type_logon, desc, "");
3171 if (IS_ERR(key)) {
3172 rc = PTR_ERR(key);
3173 goto out_err;
3174 }
3175 is_domain = 1;
3176 }
3177
3178 down_read(&key->sem);
3179 upayload = user_key_payload_locked(key);
3180 if (IS_ERR_OR_NULL(upayload)) {
3181 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
3182 goto out_key_put;
3183 }
3184
3185 /* find first : in payload */
3186 payload = upayload->data;
3187 delim = strnchr(payload, upayload->datalen, ':');
3188 cifs_dbg(FYI, "payload=%s\n", payload);
3189 if (!delim) {
3190 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
3191 upayload->datalen);
3192 rc = -EINVAL;
3193 goto out_key_put;
3194 }
3195
3196 len = delim - payload;
3197 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
3198 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
3199 len);
3200 rc = -EINVAL;
3201 goto out_key_put;
3202 }
3203
3204 vol->username = kstrndup(payload, len, GFP_KERNEL);
3205 if (!vol->username) {
3206 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
3207 len);
3208 rc = -ENOMEM;
3209 goto out_key_put;
3210 }
3211 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
3212
3213 len = key->datalen - (len + 1);
3214 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
3215 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
3216 rc = -EINVAL;
3217 kfree(vol->username);
3218 vol->username = NULL;
3219 goto out_key_put;
3220 }
3221
3222 ++delim;
3223 vol->password = kstrndup(delim, len, GFP_KERNEL);
3224 if (!vol->password) {
3225 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
3226 len);
3227 rc = -ENOMEM;
3228 kfree(vol->username);
3229 vol->username = NULL;
3230 goto out_key_put;
3231 }
3232
3233 /*
3234 * If we have a domain key then we must set the domainName in the
3235 * for the request.
3236 */
3237 if (is_domain && ses->domainName) {
3238 vol->domainname = kstrndup(ses->domainName,
3239 strlen(ses->domainName),
3240 GFP_KERNEL);
3241 if (!vol->domainname) {
3242 cifs_dbg(FYI, "Unable to allocate %zd bytes for "
3243 "domain\n", len);
3244 rc = -ENOMEM;
3245 kfree(vol->username);
3246 vol->username = NULL;
3247 kzfree(vol->password);
3248 vol->password = NULL;
3249 goto out_key_put;
3250 }
3251 }
3252
3253 out_key_put:
3254 up_read(&key->sem);
3255 key_put(key);
3256 out_err:
3257 kfree(desc);
3258 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
3259 return rc;
3260 }
3261 #else /* ! CONFIG_KEYS */
3262 static inline int
3263 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
3264 struct cifs_ses *ses __attribute__((unused)))
3265 {
3266 return -ENOSYS;
3267 }
3268 #endif /* CONFIG_KEYS */
3269
3270 /**
3271 * cifs_get_smb_ses - get a session matching @volume_info data from @server
3272 *
3273 * This function assumes it is being called from cifs_mount() where we
3274 * already got a server reference (server refcount +1). See
3275 * cifs_get_tcon() for refcount explanations.
3276 */
3277 struct cifs_ses *
3278 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
3279 {
3280 int rc = -ENOMEM;
3281 unsigned int xid;
3282 struct cifs_ses *ses;
3283 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3284 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3285
3286 xid = get_xid();
3287
3288 ses = cifs_find_smb_ses(server, volume_info);
3289 if (ses) {
3290 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
3291 ses->status);
3292
3293 mutex_lock(&ses->session_mutex);
3294 rc = cifs_negotiate_protocol(xid, ses);
3295 if (rc) {
3296 mutex_unlock(&ses->session_mutex);
3297 /* problem -- put our ses reference */
3298 cifs_put_smb_ses(ses);
3299 free_xid(xid);
3300 return ERR_PTR(rc);
3301 }
3302 if (ses->need_reconnect) {
3303 cifs_dbg(FYI, "Session needs reconnect\n");
3304 rc = cifs_setup_session(xid, ses,
3305 volume_info->local_nls);
3306 if (rc) {
3307 mutex_unlock(&ses->session_mutex);
3308 /* problem -- put our reference */
3309 cifs_put_smb_ses(ses);
3310 free_xid(xid);
3311 return ERR_PTR(rc);
3312 }
3313 }
3314 mutex_unlock(&ses->session_mutex);
3315
3316 /* existing SMB ses has a server reference already */
3317 cifs_put_tcp_session(server, 0);
3318 free_xid(xid);
3319 return ses;
3320 }
3321
3322 cifs_dbg(FYI, "Existing smb sess not found\n");
3323 ses = sesInfoAlloc();
3324 if (ses == NULL)
3325 goto get_ses_fail;
3326
3327 /* new SMB session uses our server ref */
3328 ses->server = server;
3329 if (server->dstaddr.ss_family == AF_INET6)
3330 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
3331 else
3332 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
3333
3334 if (volume_info->username) {
3335 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
3336 if (!ses->user_name)
3337 goto get_ses_fail;
3338 }
3339
3340 /* volume_info->password freed at unmount */
3341 if (volume_info->password) {
3342 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
3343 if (!ses->password)
3344 goto get_ses_fail;
3345 }
3346 if (volume_info->domainname) {
3347 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
3348 if (!ses->domainName)
3349 goto get_ses_fail;
3350 }
3351 if (volume_info->domainauto)
3352 ses->domainAuto = volume_info->domainauto;
3353 ses->cred_uid = volume_info->cred_uid;
3354 ses->linux_uid = volume_info->linux_uid;
3355
3356 ses->sectype = volume_info->sectype;
3357 ses->sign = volume_info->sign;
3358 mutex_lock(&ses->session_mutex);
3359
3360 /* add server as first channel */
3361 ses->chans[0].server = server;
3362 ses->chan_count = 1;
3363 ses->chan_max = volume_info->multichannel ? volume_info->max_channels:1;
3364
3365 rc = cifs_negotiate_protocol(xid, ses);
3366 if (!rc)
3367 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
3368
3369 /* each channel uses a different signing key */
3370 memcpy(ses->chans[0].signkey, ses->smb3signingkey,
3371 sizeof(ses->smb3signingkey));
3372
3373 mutex_unlock(&ses->session_mutex);
3374 if (rc)
3375 goto get_ses_fail;
3376
3377 /* success, put it on the list and add it as first channel */
3378 spin_lock(&cifs_tcp_ses_lock);
3379 list_add(&ses->smb_ses_list, &server->smb_ses_list);
3380 spin_unlock(&cifs_tcp_ses_lock);
3381
3382 free_xid(xid);
3383
3384 cifs_setup_ipc(ses, volume_info);
3385
3386 return ses;
3387
3388 get_ses_fail:
3389 sesInfoFree(ses);
3390 free_xid(xid);
3391 return ERR_PTR(rc);
3392 }
3393
3394 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
3395 {
3396 if (tcon->tidStatus == CifsExiting)
3397 return 0;
3398 if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
3399 return 0;
3400 if (tcon->seal != volume_info->seal)
3401 return 0;
3402 if (tcon->snapshot_time != volume_info->snapshot_time)
3403 return 0;
3404 if (tcon->handle_timeout != volume_info->handle_timeout)
3405 return 0;
3406 if (tcon->no_lease != volume_info->no_lease)
3407 return 0;
3408 return 1;
3409 }
3410
3411 static struct cifs_tcon *
3412 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3413 {
3414 struct list_head *tmp;
3415 struct cifs_tcon *tcon;
3416
3417 spin_lock(&cifs_tcp_ses_lock);
3418 list_for_each(tmp, &ses->tcon_list) {
3419 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
3420 if (!match_tcon(tcon, volume_info))
3421 continue;
3422 ++tcon->tc_count;
3423 spin_unlock(&cifs_tcp_ses_lock);
3424 return tcon;
3425 }
3426 spin_unlock(&cifs_tcp_ses_lock);
3427 return NULL;
3428 }
3429
3430 void
3431 cifs_put_tcon(struct cifs_tcon *tcon)
3432 {
3433 unsigned int xid;
3434 struct cifs_ses *ses;
3435
3436 /*
3437 * IPC tcon share the lifetime of their session and are
3438 * destroyed in the session put function
3439 */
3440 if (tcon == NULL || tcon->ipc)
3441 return;
3442
3443 ses = tcon->ses;
3444 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
3445 spin_lock(&cifs_tcp_ses_lock);
3446 if (--tcon->tc_count > 0) {
3447 spin_unlock(&cifs_tcp_ses_lock);
3448 return;
3449 }
3450
3451 list_del_init(&tcon->tcon_list);
3452 spin_unlock(&cifs_tcp_ses_lock);
3453
3454 xid = get_xid();
3455 if (ses->server->ops->tree_disconnect)
3456 ses->server->ops->tree_disconnect(xid, tcon);
3457 _free_xid(xid);
3458
3459 cifs_fscache_release_super_cookie(tcon);
3460 tconInfoFree(tcon);
3461 cifs_put_smb_ses(ses);
3462 }
3463
3464 /**
3465 * cifs_get_tcon - get a tcon matching @volume_info data from @ses
3466 *
3467 * - tcon refcount is the number of mount points using the tcon.
3468 * - ses refcount is the number of tcon using the session.
3469 *
3470 * 1. This function assumes it is being called from cifs_mount() where
3471 * we already got a session reference (ses refcount +1).
3472 *
3473 * 2. Since we're in the context of adding a mount point, the end
3474 * result should be either:
3475 *
3476 * a) a new tcon already allocated with refcount=1 (1 mount point) and
3477 * its session refcount incremented (1 new tcon). This +1 was
3478 * already done in (1).
3479 *
3480 * b) an existing tcon with refcount+1 (add a mount point to it) and
3481 * identical ses refcount (no new tcon). Because of (1) we need to
3482 * decrement the ses refcount.
3483 */
3484 static struct cifs_tcon *
3485 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
3486 {
3487 int rc, xid;
3488 struct cifs_tcon *tcon;
3489
3490 tcon = cifs_find_tcon(ses, volume_info);
3491 if (tcon) {
3492 /*
3493 * tcon has refcount already incremented but we need to
3494 * decrement extra ses reference gotten by caller (case b)
3495 */
3496 cifs_dbg(FYI, "Found match on UNC path\n");
3497 cifs_put_smb_ses(ses);
3498 return tcon;
3499 }
3500
3501 if (!ses->server->ops->tree_connect) {
3502 rc = -ENOSYS;
3503 goto out_fail;
3504 }
3505
3506 tcon = tconInfoAlloc();
3507 if (tcon == NULL) {
3508 rc = -ENOMEM;
3509 goto out_fail;
3510 }
3511
3512 if (volume_info->snapshot_time) {
3513 if (ses->server->vals->protocol_id == 0) {
3514 cifs_dbg(VFS,
3515 "Use SMB2 or later for snapshot mount option\n");
3516 rc = -EOPNOTSUPP;
3517 goto out_fail;
3518 } else
3519 tcon->snapshot_time = volume_info->snapshot_time;
3520 }
3521
3522 if (volume_info->handle_timeout) {
3523 if (ses->server->vals->protocol_id == 0) {
3524 cifs_dbg(VFS,
3525 "Use SMB2.1 or later for handle timeout option\n");
3526 rc = -EOPNOTSUPP;
3527 goto out_fail;
3528 } else
3529 tcon->handle_timeout = volume_info->handle_timeout;
3530 }
3531
3532 tcon->ses = ses;
3533 if (volume_info->password) {
3534 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
3535 if (!tcon->password) {
3536 rc = -ENOMEM;
3537 goto out_fail;
3538 }
3539 }
3540
3541 if (volume_info->seal) {
3542 if (ses->server->vals->protocol_id == 0) {
3543 cifs_dbg(VFS,
3544 "SMB3 or later required for encryption\n");
3545 rc = -EOPNOTSUPP;
3546 goto out_fail;
3547 } else if (tcon->ses->server->capabilities &
3548 SMB2_GLOBAL_CAP_ENCRYPTION)
3549 tcon->seal = true;
3550 else {
3551 cifs_dbg(VFS, "Encryption is not supported on share\n");
3552 rc = -EOPNOTSUPP;
3553 goto out_fail;
3554 }
3555 }
3556
3557 if (volume_info->linux_ext) {
3558 if (ses->server->posix_ext_supported) {
3559 tcon->posix_extensions = true;
3560 printk_once(KERN_WARNING
3561 "SMB3.11 POSIX Extensions are experimental\n");
3562 } else {
3563 cifs_dbg(VFS, "Server does not support mounting with posix SMB3.11 extensions.\n");
3564 rc = -EOPNOTSUPP;
3565 goto out_fail;
3566 }
3567 }
3568
3569 /*
3570 * BB Do we need to wrap session_mutex around this TCon call and Unix
3571 * SetFS as we do on SessSetup and reconnect?
3572 */
3573 xid = get_xid();
3574 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
3575 volume_info->local_nls);
3576 free_xid(xid);
3577 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
3578 if (rc)
3579 goto out_fail;
3580
3581 tcon->use_persistent = false;
3582 /* check if SMB2 or later, CIFS does not support persistent handles */
3583 if (volume_info->persistent) {
3584 if (ses->server->vals->protocol_id == 0) {
3585 cifs_dbg(VFS,
3586 "SMB3 or later required for persistent handles\n");
3587 rc = -EOPNOTSUPP;
3588 goto out_fail;
3589 } else if (ses->server->capabilities &
3590 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3591 tcon->use_persistent = true;
3592 else /* persistent handles requested but not supported */ {
3593 cifs_dbg(VFS,
3594 "Persistent handles not supported on share\n");
3595 rc = -EOPNOTSUPP;
3596 goto out_fail;
3597 }
3598 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3599 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3600 && (volume_info->nopersistent == false)) {
3601 cifs_dbg(FYI, "enabling persistent handles\n");
3602 tcon->use_persistent = true;
3603 } else if (volume_info->resilient) {
3604 if (ses->server->vals->protocol_id == 0) {
3605 cifs_dbg(VFS,
3606 "SMB2.1 or later required for resilient handles\n");
3607 rc = -EOPNOTSUPP;
3608 goto out_fail;
3609 }
3610 tcon->use_resilient = true;
3611 }
3612
3613 /* If the user really knows what they are doing they can override */
3614 if (tcon->share_flags & SMB2_SHAREFLAG_NO_CACHING) {
3615 if (volume_info->cache_ro)
3616 cifs_dbg(VFS, "cache=ro requested on mount but NO_CACHING flag set on share\n");
3617 else if (volume_info->cache_rw)
3618 cifs_dbg(VFS, "cache=singleclient requested on mount but NO_CACHING flag set on share\n");
3619 }
3620
3621 /*
3622 * We can have only one retry value for a connection to a share so for
3623 * resources mounted more than once to the same server share the last
3624 * value passed in for the retry flag is used.
3625 */
3626 tcon->retry = volume_info->retry;
3627 tcon->nocase = volume_info->nocase;
3628 tcon->nohandlecache = volume_info->nohandlecache;
3629 tcon->local_lease = volume_info->local_lease;
3630 tcon->no_lease = volume_info->no_lease;
3631 INIT_LIST_HEAD(&tcon->pending_opens);
3632
3633 spin_lock(&cifs_tcp_ses_lock);
3634 list_add(&tcon->tcon_list, &ses->tcon_list);
3635 spin_unlock(&cifs_tcp_ses_lock);
3636
3637 cifs_fscache_get_super_cookie(tcon);
3638
3639 return tcon;
3640
3641 out_fail:
3642 tconInfoFree(tcon);
3643 return ERR_PTR(rc);
3644 }
3645
3646 void
3647 cifs_put_tlink(struct tcon_link *tlink)
3648 {
3649 if (!tlink || IS_ERR(tlink))
3650 return;
3651
3652 if (!atomic_dec_and_test(&tlink->tl_count) ||
3653 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
3654 tlink->tl_time = jiffies;
3655 return;
3656 }
3657
3658 if (!IS_ERR(tlink_tcon(tlink)))
3659 cifs_put_tcon(tlink_tcon(tlink));
3660 kfree(tlink);
3661 return;
3662 }
3663
3664 static int
3665 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3666 {
3667 struct cifs_sb_info *old = CIFS_SB(sb);
3668 struct cifs_sb_info *new = mnt_data->cifs_sb;
3669 unsigned int oldflags = old->mnt_cifs_flags & CIFS_MOUNT_MASK;
3670 unsigned int newflags = new->mnt_cifs_flags & CIFS_MOUNT_MASK;
3671
3672 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
3673 return 0;
3674
3675 if (old->mnt_cifs_serverino_autodisabled)
3676 newflags &= ~CIFS_MOUNT_SERVER_INUM;
3677
3678 if (oldflags != newflags)
3679 return 0;
3680
3681 /*
3682 * We want to share sb only if we don't specify an r/wsize or
3683 * specified r/wsize is greater than or equal to existing one.
3684 */
3685 if (new->wsize && new->wsize < old->wsize)
3686 return 0;
3687
3688 if (new->rsize && new->rsize < old->rsize)
3689 return 0;
3690
3691 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
3692 return 0;
3693
3694 if (old->mnt_file_mode != new->mnt_file_mode ||
3695 old->mnt_dir_mode != new->mnt_dir_mode)
3696 return 0;
3697
3698 if (strcmp(old->local_nls->charset, new->local_nls->charset))
3699 return 0;
3700
3701 if (old->actimeo != new->actimeo)
3702 return 0;
3703
3704 return 1;
3705 }
3706
3707 static int
3708 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
3709 {
3710 struct cifs_sb_info *old = CIFS_SB(sb);
3711 struct cifs_sb_info *new = mnt_data->cifs_sb;
3712 bool old_set = (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3713 old->prepath;
3714 bool new_set = (new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) &&
3715 new->prepath;
3716
3717 if (old_set && new_set && !strcmp(new->prepath, old->prepath))
3718 return 1;
3719 else if (!old_set && !new_set)
3720 return 1;
3721
3722 return 0;
3723 }
3724
3725 int
3726 cifs_match_super(struct super_block *sb, void *data)
3727 {
3728 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
3729 struct smb_vol *volume_info;
3730 struct cifs_sb_info *cifs_sb;
3731 struct TCP_Server_Info *tcp_srv;
3732 struct cifs_ses *ses;
3733 struct cifs_tcon *tcon;
3734 struct tcon_link *tlink;
3735 int rc = 0;
3736
3737 spin_lock(&cifs_tcp_ses_lock);
3738 cifs_sb = CIFS_SB(sb);
3739 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3740 if (IS_ERR(tlink)) {
3741 spin_unlock(&cifs_tcp_ses_lock);
3742 return rc;
3743 }
3744 tcon = tlink_tcon(tlink);
3745 ses = tcon->ses;
3746 tcp_srv = ses->server;
3747
3748 volume_info = mnt_data->vol;
3749
3750 if (!match_server(tcp_srv, volume_info) ||
3751 !match_session(ses, volume_info) ||
3752 !match_tcon(tcon, volume_info) ||
3753 !match_prepath(sb, mnt_data)) {
3754 rc = 0;
3755 goto out;
3756 }
3757
3758 rc = compare_mount_options(sb, mnt_data);
3759 out:
3760 spin_unlock(&cifs_tcp_ses_lock);
3761 cifs_put_tlink(tlink);
3762 return rc;
3763 }
3764
3765 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3766 static struct lock_class_key cifs_key[2];
3767 static struct lock_class_key cifs_slock_key[2];
3768
3769 static inline void
3770 cifs_reclassify_socket4(struct socket *sock)
3771 {
3772 struct sock *sk = sock->sk;
3773 BUG_ON(!sock_allow_reclassification(sk));
3774 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3775 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3776 }
3777
3778 static inline void
3779 cifs_reclassify_socket6(struct socket *sock)
3780 {
3781 struct sock *sk = sock->sk;
3782 BUG_ON(!sock_allow_reclassification(sk));
3783 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3784 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3785 }
3786 #else
3787 static inline void
3788 cifs_reclassify_socket4(struct socket *sock)
3789 {
3790 }
3791
3792 static inline void
3793 cifs_reclassify_socket6(struct socket *sock)
3794 {
3795 }
3796 #endif
3797
3798 /* See RFC1001 section 14 on representation of Netbios names */
3799 static void rfc1002mangle(char *target, char *source, unsigned int length)
3800 {
3801 unsigned int i, j;
3802
3803 for (i = 0, j = 0; i < (length); i++) {
3804 /* mask a nibble at a time and encode */
3805 target[j] = 'A' + (0x0F & (source[i] >> 4));
3806 target[j+1] = 'A' + (0x0F & source[i]);
3807 j += 2;
3808 }
3809
3810 }
3811
3812 static int
3813 bind_socket(struct TCP_Server_Info *server)
3814 {
3815 int rc = 0;
3816 if (server->srcaddr.ss_family != AF_UNSPEC) {
3817 /* Bind to the specified local IP address */
3818 struct socket *socket = server->ssocket;
3819 rc = socket->ops->bind(socket,
3820 (struct sockaddr *) &server->srcaddr,
3821 sizeof(server->srcaddr));
3822 if (rc < 0) {
3823 struct sockaddr_in *saddr4;
3824 struct sockaddr_in6 *saddr6;
3825 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3826 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3827 if (saddr6->sin6_family == AF_INET6)
3828 cifs_server_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3829 &saddr6->sin6_addr, rc);
3830 else
3831 cifs_server_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3832 &saddr4->sin_addr.s_addr, rc);
3833 }
3834 }
3835 return rc;
3836 }
3837
3838 static int
3839 ip_rfc1001_connect(struct TCP_Server_Info *server)
3840 {
3841 int rc = 0;
3842 /*
3843 * some servers require RFC1001 sessinit before sending
3844 * negprot - BB check reconnection in case where second
3845 * sessinit is sent but no second negprot
3846 */
3847 struct rfc1002_session_packet *ses_init_buf;
3848 struct smb_hdr *smb_buf;
3849 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3850 GFP_KERNEL);
3851 if (ses_init_buf) {
3852 ses_init_buf->trailer.session_req.called_len = 32;
3853
3854 if (server->server_RFC1001_name[0] != 0)
3855 rfc1002mangle(ses_init_buf->trailer.
3856 session_req.called_name,
3857 server->server_RFC1001_name,
3858 RFC1001_NAME_LEN_WITH_NULL);
3859 else
3860 rfc1002mangle(ses_init_buf->trailer.
3861 session_req.called_name,
3862 DEFAULT_CIFS_CALLED_NAME,
3863 RFC1001_NAME_LEN_WITH_NULL);
3864
3865 ses_init_buf->trailer.session_req.calling_len = 32;
3866
3867 /*
3868 * calling name ends in null (byte 16) from old smb
3869 * convention.
3870 */
3871 if (server->workstation_RFC1001_name[0] != 0)
3872 rfc1002mangle(ses_init_buf->trailer.
3873 session_req.calling_name,
3874 server->workstation_RFC1001_name,
3875 RFC1001_NAME_LEN_WITH_NULL);
3876 else
3877 rfc1002mangle(ses_init_buf->trailer.
3878 session_req.calling_name,
3879 "LINUX_CIFS_CLNT",
3880 RFC1001_NAME_LEN_WITH_NULL);
3881
3882 ses_init_buf->trailer.session_req.scope1 = 0;
3883 ses_init_buf->trailer.session_req.scope2 = 0;
3884 smb_buf = (struct smb_hdr *)ses_init_buf;
3885
3886 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3887 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3888 rc = smb_send(server, smb_buf, 0x44);
3889 kfree(ses_init_buf);
3890 /*
3891 * RFC1001 layer in at least one server
3892 * requires very short break before negprot
3893 * presumably because not expecting negprot
3894 * to follow so fast. This is a simple
3895 * solution that works without
3896 * complicating the code and causes no
3897 * significant slowing down on mount
3898 * for everyone else
3899 */
3900 usleep_range(1000, 2000);
3901 }
3902 /*
3903 * else the negprot may still work without this
3904 * even though malloc failed
3905 */
3906
3907 return rc;
3908 }
3909
3910 static int
3911 generic_ip_connect(struct TCP_Server_Info *server)
3912 {
3913 int rc = 0;
3914 __be16 sport;
3915 int slen, sfamily;
3916 struct socket *socket = server->ssocket;
3917 struct sockaddr *saddr;
3918
3919 saddr = (struct sockaddr *) &server->dstaddr;
3920
3921 if (server->dstaddr.ss_family == AF_INET6) {
3922 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3923 slen = sizeof(struct sockaddr_in6);
3924 sfamily = AF_INET6;
3925 } else {
3926 sport = ((struct sockaddr_in *) saddr)->sin_port;
3927 slen = sizeof(struct sockaddr_in);
3928 sfamily = AF_INET;
3929 }
3930
3931 if (socket == NULL) {
3932 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3933 IPPROTO_TCP, &socket, 1);
3934 if (rc < 0) {
3935 cifs_server_dbg(VFS, "Error %d creating socket\n", rc);
3936 server->ssocket = NULL;
3937 return rc;
3938 }
3939
3940 /* BB other socket options to set KEEPALIVE, NODELAY? */
3941 cifs_dbg(FYI, "Socket created\n");
3942 server->ssocket = socket;
3943 socket->sk->sk_allocation = GFP_NOFS;
3944 if (sfamily == AF_INET6)
3945 cifs_reclassify_socket6(socket);
3946 else
3947 cifs_reclassify_socket4(socket);
3948 }
3949
3950 rc = bind_socket(server);
3951 if (rc < 0)
3952 return rc;
3953
3954 /*
3955 * Eventually check for other socket options to change from
3956 * the default. sock_setsockopt not used because it expects
3957 * user space buffer
3958 */
3959 socket->sk->sk_rcvtimeo = 7 * HZ;
3960 socket->sk->sk_sndtimeo = 5 * HZ;
3961
3962 /* make the bufsizes depend on wsize/rsize and max requests */
3963 if (server->noautotune) {
3964 if (socket->sk->sk_sndbuf < (200 * 1024))
3965 socket->sk->sk_sndbuf = 200 * 1024;
3966 if (socket->sk->sk_rcvbuf < (140 * 1024))
3967 socket->sk->sk_rcvbuf = 140 * 1024;
3968 }
3969
3970 if (server->tcp_nodelay) {
3971 int val = 1;
3972 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3973 (char *)&val, sizeof(val));
3974 if (rc)
3975 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3976 rc);
3977 }
3978
3979 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3980 socket->sk->sk_sndbuf,
3981 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3982
3983 rc = socket->ops->connect(socket, saddr, slen,
3984 server->noblockcnt ? O_NONBLOCK : 0);
3985 /*
3986 * When mounting SMB root file systems, we do not want to block in
3987 * connect. Otherwise bail out and then let cifs_reconnect() perform
3988 * reconnect failover - if possible.
3989 */
3990 if (server->noblockcnt && rc == -EINPROGRESS)
3991 rc = 0;
3992 if (rc < 0) {
3993 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3994 sock_release(socket);
3995 server->ssocket = NULL;
3996 return rc;
3997 }
3998
3999 if (sport == htons(RFC1001_PORT))
4000 rc = ip_rfc1001_connect(server);
4001
4002 return rc;
4003 }
4004
4005 static int
4006 ip_connect(struct TCP_Server_Info *server)
4007 {
4008 __be16 *sport;
4009 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
4010 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
4011
4012 if (server->dstaddr.ss_family == AF_INET6)
4013 sport = &addr6->sin6_port;
4014 else
4015 sport = &addr->sin_port;
4016
4017 if (*sport == 0) {
4018 int rc;
4019
4020 /* try with 445 port at first */
4021 *sport = htons(CIFS_PORT);
4022
4023 rc = generic_ip_connect(server);
4024 if (rc >= 0)
4025 return rc;
4026
4027 /* if it failed, try with 139 port */
4028 *sport = htons(RFC1001_PORT);
4029 }
4030
4031 return generic_ip_connect(server);
4032 }
4033
4034 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
4035 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
4036 {
4037 /* if we are reconnecting then should we check to see if
4038 * any requested capabilities changed locally e.g. via
4039 * remount but we can not do much about it here
4040 * if they have (even if we could detect it by the following)
4041 * Perhaps we could add a backpointer to array of sb from tcon
4042 * or if we change to make all sb to same share the same
4043 * sb as NFS - then we only have one backpointer to sb.
4044 * What if we wanted to mount the server share twice once with
4045 * and once without posixacls or posix paths? */
4046 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4047
4048 if (vol_info && vol_info->no_linux_ext) {
4049 tcon->fsUnixInfo.Capability = 0;
4050 tcon->unix_ext = 0; /* Unix Extensions disabled */
4051 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
4052 return;
4053 } else if (vol_info)
4054 tcon->unix_ext = 1; /* Unix Extensions supported */
4055
4056 if (tcon->unix_ext == 0) {
4057 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
4058 return;
4059 }
4060
4061 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
4062 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
4063 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
4064 /* check for reconnect case in which we do not
4065 want to change the mount behavior if we can avoid it */
4066 if (vol_info == NULL) {
4067 /* turn off POSIX ACL and PATHNAMES if not set
4068 originally at mount time */
4069 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
4070 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4071 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4072 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4073 cifs_dbg(VFS, "POSIXPATH support change\n");
4074 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4075 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
4076 cifs_dbg(VFS, "possible reconnect error\n");
4077 cifs_dbg(VFS, "server disabled POSIX path support\n");
4078 }
4079 }
4080
4081 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4082 cifs_dbg(VFS, "per-share encryption not supported yet\n");
4083
4084 cap &= CIFS_UNIX_CAP_MASK;
4085 if (vol_info && vol_info->no_psx_acl)
4086 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
4087 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
4088 cifs_dbg(FYI, "negotiated posix acl support\n");
4089 if (cifs_sb)
4090 cifs_sb->mnt_cifs_flags |=
4091 CIFS_MOUNT_POSIXACL;
4092 }
4093
4094 if (vol_info && vol_info->posix_paths == 0)
4095 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
4096 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
4097 cifs_dbg(FYI, "negotiate posix pathnames\n");
4098 if (cifs_sb)
4099 cifs_sb->mnt_cifs_flags |=
4100 CIFS_MOUNT_POSIX_PATHS;
4101 }
4102
4103 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
4104 #ifdef CONFIG_CIFS_DEBUG2
4105 if (cap & CIFS_UNIX_FCNTL_CAP)
4106 cifs_dbg(FYI, "FCNTL cap\n");
4107 if (cap & CIFS_UNIX_EXTATTR_CAP)
4108 cifs_dbg(FYI, "EXTATTR cap\n");
4109 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
4110 cifs_dbg(FYI, "POSIX path cap\n");
4111 if (cap & CIFS_UNIX_XATTR_CAP)
4112 cifs_dbg(FYI, "XATTR cap\n");
4113 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
4114 cifs_dbg(FYI, "POSIX ACL cap\n");
4115 if (cap & CIFS_UNIX_LARGE_READ_CAP)
4116 cifs_dbg(FYI, "very large read cap\n");
4117 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
4118 cifs_dbg(FYI, "very large write cap\n");
4119 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
4120 cifs_dbg(FYI, "transport encryption cap\n");
4121 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
4122 cifs_dbg(FYI, "mandatory transport encryption cap\n");
4123 #endif /* CIFS_DEBUG2 */
4124 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
4125 if (vol_info == NULL) {
4126 cifs_dbg(FYI, "resetting capabilities failed\n");
4127 } else
4128 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");
4129
4130 }
4131 }
4132 }
4133
4134 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
4135 struct cifs_sb_info *cifs_sb)
4136 {
4137 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
4138
4139 spin_lock_init(&cifs_sb->tlink_tree_lock);
4140 cifs_sb->tlink_tree = RB_ROOT;
4141
4142 cifs_sb->bsize = pvolume_info->bsize;
4143 /*
4144 * Temporarily set r/wsize for matching superblock. If we end up using
4145 * new sb then client will later negotiate it downward if needed.
4146 */
4147 cifs_sb->rsize = pvolume_info->rsize;
4148 cifs_sb->wsize = pvolume_info->wsize;
4149
4150 cifs_sb->mnt_uid = pvolume_info->linux_uid;
4151 cifs_sb->mnt_gid = pvolume_info->linux_gid;
4152 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
4153 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
4154 cifs_dbg(FYI, "file mode: %04ho dir mode: %04ho\n",
4155 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
4156
4157 cifs_sb->actimeo = pvolume_info->actimeo;
4158 cifs_sb->local_nls = pvolume_info->local_nls;
4159
4160 if (pvolume_info->nodfs)
4161 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_DFS;
4162 if (pvolume_info->noperm)
4163 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
4164 if (pvolume_info->setuids)
4165 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
4166 if (pvolume_info->setuidfromacl)
4167 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
4168 if (pvolume_info->server_ino)
4169 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
4170 if (pvolume_info->remap)
4171 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
4172 if (pvolume_info->sfu_remap)
4173 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
4174 if (pvolume_info->no_xattr)
4175 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
4176 if (pvolume_info->sfu_emul)
4177 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
4178 if (pvolume_info->nobrl)
4179 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
4180 if (pvolume_info->nohandlecache)
4181 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_HANDLE_CACHE;
4182 if (pvolume_info->nostrictsync)
4183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
4184 if (pvolume_info->mand_lock)
4185 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
4186 if (pvolume_info->rwpidforward)
4187 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
4188 if (pvolume_info->mode_ace)
4189 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MODE_FROM_SID;
4190 if (pvolume_info->cifs_acl)
4191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
4192 if (pvolume_info->backupuid_specified) {
4193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
4194 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
4195 }
4196 if (pvolume_info->backupgid_specified) {
4197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
4198 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
4199 }
4200 if (pvolume_info->override_uid)
4201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
4202 if (pvolume_info->override_gid)
4203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
4204 if (pvolume_info->dynperm)
4205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
4206 if (pvolume_info->fsc)
4207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
4208 if (pvolume_info->multiuser)
4209 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
4210 CIFS_MOUNT_NO_PERM);
4211 if (pvolume_info->strict_io)
4212 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
4213 if (pvolume_info->direct_io) {
4214 cifs_dbg(FYI, "mounting share using direct i/o\n");
4215 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
4216 }
4217 if (pvolume_info->cache_ro) {
4218 cifs_dbg(VFS, "mounting share with read only caching. Ensure that the share will not be modified while in use.\n");
4219 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RO_CACHE;
4220 } else if (pvolume_info->cache_rw) {
4221 cifs_dbg(VFS, "mounting share in single client RW caching mode. Ensure that no other systems will be accessing the share.\n");
4222 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_RO_CACHE |
4223 CIFS_MOUNT_RW_CACHE);
4224 }
4225 if (pvolume_info->mfsymlinks) {
4226 if (pvolume_info->sfu_emul) {
4227 /*
4228 * Our SFU ("Services for Unix" emulation does not allow
4229 * creating symlinks but does allow reading existing SFU
4230 * symlinks (it does allow both creating and reading SFU
4231 * style mknod and FIFOs though). When "mfsymlinks" and
4232 * "sfu" are both enabled at the same time, it allows
4233 * reading both types of symlinks, but will only create
4234 * them with mfsymlinks format. This allows better
4235 * Apple compatibility (probably better for Samba too)
4236 * while still recognizing old Windows style symlinks.
4237 */
4238 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
4239 }
4240 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
4241 }
4242
4243 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
4244 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
4245
4246 if (pvolume_info->prepath) {
4247 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
4248 if (cifs_sb->prepath == NULL)
4249 return -ENOMEM;
4250 }
4251
4252 return 0;
4253 }
4254
4255 void
4256 cifs_cleanup_volume_info_contents(struct smb_vol *volume_info)
4257 {
4258 kfree(volume_info->username);
4259 kzfree(volume_info->password);
4260 kfree(volume_info->UNC);
4261 kfree(volume_info->domainname);
4262 kfree(volume_info->iocharset);
4263 kfree(volume_info->prepath);
4264 }
4265
4266 void
4267 cifs_cleanup_volume_info(struct smb_vol *volume_info)
4268 {
4269 if (!volume_info)
4270 return;
4271 cifs_cleanup_volume_info_contents(volume_info);
4272 kfree(volume_info);
4273 }
4274
4275 /* Release all succeed connections */
4276 static inline void mount_put_conns(struct cifs_sb_info *cifs_sb,
4277 unsigned int xid,
4278 struct TCP_Server_Info *server,
4279 struct cifs_ses *ses, struct cifs_tcon *tcon)
4280 {
4281 int rc = 0;
4282
4283 if (tcon)
4284 cifs_put_tcon(tcon);
4285 else if (ses)
4286 cifs_put_smb_ses(ses);
4287 else if (server)
4288 cifs_put_tcp_session(server, 0);
4289 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
4290 free_xid(xid);
4291 }
4292
4293 /* Get connections for tcp, ses and tcon */
4294 static int mount_get_conns(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
4295 unsigned int *xid,
4296 struct TCP_Server_Info **nserver,
4297 struct cifs_ses **nses, struct cifs_tcon **ntcon)
4298 {
4299 int rc = 0;
4300 struct TCP_Server_Info *server;
4301 struct cifs_ses *ses;
4302 struct cifs_tcon *tcon;
4303
4304 *nserver = NULL;
4305 *nses = NULL;
4306 *ntcon = NULL;
4307
4308 *xid = get_xid();
4309
4310 /* get a reference to a tcp session */
4311 server = cifs_get_tcp_session(vol);
4312 if (IS_ERR(server)) {
4313 rc = PTR_ERR(server);
4314 return rc;
4315 }
4316
4317 *nserver = server;
4318
4319 if ((vol->max_credits < 20) || (vol->max_credits > 60000))
4320 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
4321 else
4322 server->max_credits = vol->max_credits;
4323
4324 /* get a reference to a SMB session */
4325 ses = cifs_get_smb_ses(server, vol);
4326 if (IS_ERR(ses)) {
4327 rc = PTR_ERR(ses);
4328 return rc;
4329 }
4330
4331 *nses = ses;
4332
4333 if ((vol->persistent == true) && (!(ses->server->capabilities &
4334 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES))) {
4335 cifs_server_dbg(VFS, "persistent handles not supported by server\n");
4336 return -EOPNOTSUPP;
4337 }
4338
4339 /* search for existing tcon to this server share */
4340 tcon = cifs_get_tcon(ses, vol);
4341 if (IS_ERR(tcon)) {
4342 rc = PTR_ERR(tcon);
4343 return rc;
4344 }
4345
4346 *ntcon = tcon;
4347
4348 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
4349 if (tcon->posix_extensions)
4350 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
4351
4352 /* tell server which Unix caps we support */
4353 if (cap_unix(tcon->ses)) {
4354 /*
4355 * reset of caps checks mount to see if unix extensions disabled
4356 * for just this mount.
4357 */
4358 reset_cifs_unix_caps(*xid, tcon, cifs_sb, vol);
4359 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
4360 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
4361 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP))
4362 return -EACCES;
4363 } else
4364 tcon->unix_ext = 0; /* server does not support them */
4365
4366 /* do not care if a following call succeed - informational */
4367 if (!tcon->pipe && server->ops->qfs_tcon) {
4368 server->ops->qfs_tcon(*xid, tcon, cifs_sb);
4369 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RO_CACHE) {
4370 if (tcon->fsDevInfo.DeviceCharacteristics &
4371 cpu_to_le32(FILE_READ_ONLY_DEVICE))
4372 cifs_dbg(VFS, "mounted to read only share\n");
4373 else if ((cifs_sb->mnt_cifs_flags &
4374 CIFS_MOUNT_RW_CACHE) == 0)
4375 cifs_dbg(VFS, "read only mount of RW share\n");
4376 /* no need to log a RW mount of a typical RW share */
4377 }
4378 }
4379
4380 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, vol);
4381 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, vol);
4382
4383 return 0;
4384 }
4385
4386 static int mount_setup_tlink(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
4387 struct cifs_tcon *tcon)
4388 {
4389 struct tcon_link *tlink;
4390
4391 /* hang the tcon off of the superblock */
4392 tlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4393 if (tlink == NULL)
4394 return -ENOMEM;
4395
4396 tlink->tl_uid = ses->linux_uid;
4397 tlink->tl_tcon = tcon;
4398 tlink->tl_time = jiffies;
4399 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
4400 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4401
4402 cifs_sb->master_tlink = tlink;
4403 spin_lock(&cifs_sb->tlink_tree_lock);
4404 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4405 spin_unlock(&cifs_sb->tlink_tree_lock);
4406
4407 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4408 TLINK_IDLE_EXPIRE);
4409 return 0;
4410 }
4411
4412 #ifdef CONFIG_CIFS_DFS_UPCALL
4413 /*
4414 * cifs_build_path_to_root returns full path to root when we do not have an
4415 * exiting connection (tcon)
4416 */
4417 static char *
4418 build_unc_path_to_root(const struct smb_vol *vol,
4419 const struct cifs_sb_info *cifs_sb, bool useppath)
4420 {
4421 char *full_path, *pos;
4422 unsigned int pplen = useppath && vol->prepath ?
4423 strlen(vol->prepath) + 1 : 0;
4424 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
4425
4426 if (unc_len > MAX_TREE_SIZE)
4427 return ERR_PTR(-EINVAL);
4428
4429 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
4430 if (full_path == NULL)
4431 return ERR_PTR(-ENOMEM);
4432
4433 memcpy(full_path, vol->UNC, unc_len);
4434 pos = full_path + unc_len;
4435
4436 if (pplen) {
4437 *pos = CIFS_DIR_SEP(cifs_sb);
4438 memcpy(pos + 1, vol->prepath, pplen);
4439 pos += pplen;
4440 }
4441
4442 *pos = '\0'; /* add trailing null */
4443 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
4444 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
4445 return full_path;
4446 }
4447
4448 /**
4449 * expand_dfs_referral - Perform a dfs referral query and update the cifs_sb
4450 *
4451 *
4452 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
4453 * to a string containing updated options for the submount. Otherwise it
4454 * will be left untouched.
4455 *
4456 * Returns the rc from get_dfs_path to the caller, which can be used to
4457 * determine whether there were referrals.
4458 */
4459 static int
4460 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
4461 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
4462 int check_prefix)
4463 {
4464 int rc;
4465 struct dfs_info3_param referral = {0};
4466 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
4467
4468 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4469 return -EREMOTE;
4470
4471 full_path = build_unc_path_to_root(volume_info, cifs_sb, true);
4472 if (IS_ERR(full_path))
4473 return PTR_ERR(full_path);
4474
4475 /* For DFS paths, skip the first '\' of the UNC */
4476 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
4477
4478 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4479 ref_path, &referral, NULL);
4480 if (!rc) {
4481 char *fake_devname = NULL;
4482
4483 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
4484 full_path + 1, &referral,
4485 &fake_devname);
4486 free_dfs_info_param(&referral);
4487
4488 if (IS_ERR(mdata)) {
4489 rc = PTR_ERR(mdata);
4490 mdata = NULL;
4491 } else {
4492 cifs_cleanup_volume_info_contents(volume_info);
4493 rc = cifs_setup_volume_info(volume_info, mdata,
4494 fake_devname, false);
4495 }
4496 kfree(fake_devname);
4497 kfree(cifs_sb->mountdata);
4498 cifs_sb->mountdata = mdata;
4499 }
4500 kfree(full_path);
4501 return rc;
4502 }
4503
4504 static inline int get_next_dfs_tgt(const char *path,
4505 struct dfs_cache_tgt_list *tgt_list,
4506 struct dfs_cache_tgt_iterator **tgt_it)
4507 {
4508 if (!*tgt_it)
4509 *tgt_it = dfs_cache_get_tgt_iterator(tgt_list);
4510 else
4511 *tgt_it = dfs_cache_get_next_tgt(tgt_list, *tgt_it);
4512 return !*tgt_it ? -EHOSTDOWN : 0;
4513 }
4514
4515 static int update_vol_info(const struct dfs_cache_tgt_iterator *tgt_it,
4516 struct smb_vol *fake_vol, struct smb_vol *vol)
4517 {
4518 const char *tgt = dfs_cache_get_tgt_name(tgt_it);
4519 int len = strlen(tgt) + 2;
4520 char *new_unc;
4521
4522 new_unc = kmalloc(len, GFP_KERNEL);
4523 if (!new_unc)
4524 return -ENOMEM;
4525 scnprintf(new_unc, len, "\\%s", tgt);
4526
4527 kfree(vol->UNC);
4528 vol->UNC = new_unc;
4529
4530 if (fake_vol->prepath) {
4531 kfree(vol->prepath);
4532 vol->prepath = fake_vol->prepath;
4533 fake_vol->prepath = NULL;
4534 }
4535 memcpy(&vol->dstaddr, &fake_vol->dstaddr, sizeof(vol->dstaddr));
4536
4537 return 0;
4538 }
4539
4540 static int setup_dfs_tgt_conn(const char *path,
4541 const struct dfs_cache_tgt_iterator *tgt_it,
4542 struct cifs_sb_info *cifs_sb,
4543 struct smb_vol *vol,
4544 unsigned int *xid,
4545 struct TCP_Server_Info **server,
4546 struct cifs_ses **ses,
4547 struct cifs_tcon **tcon)
4548 {
4549 int rc;
4550 struct dfs_info3_param ref = {0};
4551 char *mdata = NULL, *fake_devname = NULL;
4552 struct smb_vol fake_vol = {NULL};
4553
4554 cifs_dbg(FYI, "%s: dfs path: %s\n", __func__, path);
4555
4556 rc = dfs_cache_get_tgt_referral(path, tgt_it, &ref);
4557 if (rc)
4558 return rc;
4559
4560 mdata = cifs_compose_mount_options(cifs_sb->mountdata, path, &ref,
4561 &fake_devname);
4562 free_dfs_info_param(&ref);
4563
4564 if (IS_ERR(mdata)) {
4565 rc = PTR_ERR(mdata);
4566 mdata = NULL;
4567 } else {
4568 cifs_dbg(FYI, "%s: fake_devname: %s\n", __func__, fake_devname);
4569 rc = cifs_setup_volume_info(&fake_vol, mdata, fake_devname,
4570 false);
4571 }
4572 kfree(mdata);
4573 kfree(fake_devname);
4574
4575 if (!rc) {
4576 /*
4577 * We use a 'fake_vol' here because we need pass it down to the
4578 * mount_{get,put} functions to test connection against new DFS
4579 * targets.
4580 */
4581 mount_put_conns(cifs_sb, *xid, *server, *ses, *tcon);
4582 rc = mount_get_conns(&fake_vol, cifs_sb, xid, server, ses,
4583 tcon);
4584 if (!rc) {
4585 /*
4586 * We were able to connect to new target server.
4587 * Update current volume info with new target server.
4588 */
4589 rc = update_vol_info(tgt_it, &fake_vol, vol);
4590 }
4591 }
4592 cifs_cleanup_volume_info_contents(&fake_vol);
4593 return rc;
4594 }
4595
4596 static int mount_do_dfs_failover(const char *path,
4597 struct cifs_sb_info *cifs_sb,
4598 struct smb_vol *vol,
4599 struct cifs_ses *root_ses,
4600 unsigned int *xid,
4601 struct TCP_Server_Info **server,
4602 struct cifs_ses **ses,
4603 struct cifs_tcon **tcon)
4604 {
4605 int rc;
4606 struct dfs_cache_tgt_list tgt_list;
4607 struct dfs_cache_tgt_iterator *tgt_it = NULL;
4608
4609 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_DFS)
4610 return -EOPNOTSUPP;
4611
4612 rc = dfs_cache_noreq_find(path, NULL, &tgt_list);
4613 if (rc)
4614 return rc;
4615
4616 for (;;) {
4617 /* Get next DFS target server - if any */
4618 rc = get_next_dfs_tgt(path, &tgt_list, &tgt_it);
4619 if (rc)
4620 break;
4621 /* Connect to next DFS target */
4622 rc = setup_dfs_tgt_conn(path, tgt_it, cifs_sb, vol, xid, server,
4623 ses, tcon);
4624 if (!rc || rc == -EACCES || rc == -EOPNOTSUPP)
4625 break;
4626 }
4627 if (!rc) {
4628 /*
4629 * Update DFS target hint in DFS referral cache with the target
4630 * server we successfully reconnected to.
4631 */
4632 rc = dfs_cache_update_tgthint(*xid, root_ses ? root_ses : *ses,
4633 cifs_sb->local_nls,
4634 cifs_remap(cifs_sb), path,
4635 tgt_it);
4636 }
4637 dfs_cache_free_tgts(&tgt_list);
4638 return rc;
4639 }
4640 #endif
4641
4642 int
4643 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
4644 const char *devname, bool is_smb3)
4645 {
4646 int rc = 0;
4647
4648 if (cifs_parse_mount_options(mount_data, devname, volume_info, is_smb3))
4649 return -EINVAL;
4650
4651 if (volume_info->nullauth) {
4652 cifs_dbg(FYI, "Anonymous login\n");
4653 kfree(volume_info->username);
4654 volume_info->username = NULL;
4655 } else if (volume_info->username) {
4656 /* BB fixme parse for domain name here */
4657 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
4658 } else {
4659 cifs_dbg(VFS, "No username specified\n");
4660 /* In userspace mount helper we can get user name from alternate
4661 locations such as env variables and files on disk */
4662 return -EINVAL;
4663 }
4664
4665 /* this is needed for ASCII cp to Unicode converts */
4666 if (volume_info->iocharset == NULL) {
4667 /* load_nls_default cannot return null */
4668 volume_info->local_nls = load_nls_default();
4669 } else {
4670 volume_info->local_nls = load_nls(volume_info->iocharset);
4671 if (volume_info->local_nls == NULL) {
4672 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
4673 volume_info->iocharset);
4674 return -ELIBACC;
4675 }
4676 }
4677
4678 return rc;
4679 }
4680
4681 struct smb_vol *
4682 cifs_get_volume_info(char *mount_data, const char *devname, bool is_smb3)
4683 {
4684 int rc;
4685 struct smb_vol *volume_info;
4686
4687 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
4688 if (!volume_info)
4689 return ERR_PTR(-ENOMEM);
4690
4691 rc = cifs_setup_volume_info(volume_info, mount_data, devname, is_smb3);
4692 if (rc) {
4693 cifs_cleanup_volume_info(volume_info);
4694 volume_info = ERR_PTR(rc);
4695 }
4696
4697 return volume_info;
4698 }
4699
4700 static int
4701 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
4702 unsigned int xid,
4703 struct cifs_tcon *tcon,
4704 struct cifs_sb_info *cifs_sb,
4705 char *full_path,
4706 int added_treename)
4707 {
4708 int rc;
4709 char *s;
4710 char sep, tmp;
4711 int skip = added_treename ? 1 : 0;
4712
4713 sep = CIFS_DIR_SEP(cifs_sb);
4714 s = full_path;
4715
4716 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
4717 while (rc == 0) {
4718 /* skip separators */
4719 while (*s == sep)
4720 s++;
4721 if (!*s)
4722 break;
4723 /* next separator */
4724 while (*s && *s != sep)
4725 s++;
4726 /*
4727 * if the treename is added, we then have to skip the first
4728 * part within the separators
4729 */
4730 if (skip) {
4731 skip = 0;
4732 continue;
4733 }
4734 /*
4735 * temporarily null-terminate the path at the end of
4736 * the current component
4737 */
4738 tmp = *s;
4739 *s = 0;
4740 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4741 full_path);
4742 *s = tmp;
4743 }
4744 return rc;
4745 }
4746
4747 /*
4748 * Check if path is remote (e.g. a DFS share). Return -EREMOTE if it is,
4749 * otherwise 0.
4750 */
4751 static int is_path_remote(struct cifs_sb_info *cifs_sb, struct smb_vol *vol,
4752 const unsigned int xid,
4753 struct TCP_Server_Info *server,
4754 struct cifs_tcon *tcon)
4755 {
4756 int rc;
4757 char *full_path;
4758
4759 if (!server->ops->is_path_accessible)
4760 return -EOPNOTSUPP;
4761
4762 /*
4763 * cifs_build_path_to_root works only when we have a valid tcon
4764 */
4765 full_path = cifs_build_path_to_root(vol, cifs_sb, tcon,
4766 tcon->Flags & SMB_SHARE_IS_IN_DFS);
4767 if (full_path == NULL)
4768 return -ENOMEM;
4769
4770 cifs_dbg(FYI, "%s: full_path: %s\n", __func__, full_path);
4771
4772 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
4773 full_path);
4774 if (rc != 0 && rc != -EREMOTE) {
4775 kfree(full_path);
4776 return rc;
4777 }
4778
4779 if (rc != -EREMOTE) {
4780 rc = cifs_are_all_path_components_accessible(server, xid, tcon,
4781 cifs_sb, full_path, tcon->Flags & SMB_SHARE_IS_IN_DFS);
4782 if (rc != 0) {
4783 cifs_server_dbg(VFS, "cannot query dirs between root and final path, "
4784 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
4785 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
4786 rc = 0;
4787 }
4788 }
4789
4790 kfree(full_path);
4791 return rc;
4792 }
4793
4794 #ifdef CONFIG_CIFS_DFS_UPCALL
4795 static inline void set_root_tcon(struct cifs_sb_info *cifs_sb,
4796 struct cifs_tcon *tcon,
4797 struct cifs_tcon **root)
4798 {
4799 spin_lock(&cifs_tcp_ses_lock);
4800 tcon->tc_count++;
4801 tcon->remap = cifs_remap(cifs_sb);
4802 spin_unlock(&cifs_tcp_ses_lock);
4803 *root = tcon;
4804 }
4805
4806 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
4807 {
4808 int rc = 0;
4809 unsigned int xid;
4810 struct cifs_ses *ses;
4811 struct cifs_tcon *root_tcon = NULL;
4812 struct cifs_tcon *tcon = NULL;
4813 struct TCP_Server_Info *server;
4814 char *root_path = NULL, *full_path = NULL;
4815 char *old_mountdata, *origin_mountdata = NULL;
4816 int count;
4817
4818 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4819 if (!rc && tcon) {
4820 /* If not a standalone DFS root, then check if path is remote */
4821 rc = dfs_cache_find(xid, ses, cifs_sb->local_nls,
4822 cifs_remap(cifs_sb), vol->UNC + 1, NULL,
4823 NULL);
4824 if (rc) {
4825 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4826 if (!rc)
4827 goto out;
4828 if (rc != -EREMOTE)
4829 goto error;
4830 }
4831 }
4832 /*
4833 * If first DFS target server went offline and we failed to connect it,
4834 * server and ses pointers are NULL at this point, though we still have
4835 * chance to get a cached DFS referral in expand_dfs_referral() and
4836 * retry next target available in it.
4837 *
4838 * If a NULL ses ptr is passed to dfs_cache_find(), a lookup will be
4839 * performed against DFS path and *no* requests will be sent to server
4840 * for any new DFS referrals. Hence it's safe to skip checking whether
4841 * server or ses ptr is NULL.
4842 */
4843 if (rc == -EACCES || rc == -EOPNOTSUPP)
4844 goto error;
4845
4846 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4847 if (IS_ERR(root_path)) {
4848 rc = PTR_ERR(root_path);
4849 root_path = NULL;
4850 goto error;
4851 }
4852
4853 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4854 if (IS_ERR(full_path)) {
4855 rc = PTR_ERR(full_path);
4856 full_path = NULL;
4857 goto error;
4858 }
4859 /*
4860 * Perform an unconditional check for whether there are DFS
4861 * referrals for this path without prefix, to provide support
4862 * for DFS referrals from w2k8 servers which don't seem to respond
4863 * with PATH_NOT_COVERED to requests that include the prefix.
4864 * Chase the referral if found, otherwise continue normally.
4865 */
4866 old_mountdata = cifs_sb->mountdata;
4867 (void)expand_dfs_referral(xid, ses, vol, cifs_sb, false);
4868
4869 if (cifs_sb->mountdata == NULL) {
4870 rc = -ENOENT;
4871 goto error;
4872 }
4873
4874 /* Save DFS root volume information for DFS refresh worker */
4875 origin_mountdata = kstrndup(cifs_sb->mountdata,
4876 strlen(cifs_sb->mountdata), GFP_KERNEL);
4877 if (!origin_mountdata) {
4878 rc = -ENOMEM;
4879 goto error;
4880 }
4881
4882 if (cifs_sb->mountdata != old_mountdata) {
4883 /* If we were redirected, reconnect to new target server */
4884 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4885 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
4886 }
4887 if (rc) {
4888 if (rc == -EACCES || rc == -EOPNOTSUPP)
4889 goto error;
4890 /* Perform DFS failover to any other DFS targets */
4891 rc = mount_do_dfs_failover(root_path + 1, cifs_sb, vol, NULL,
4892 &xid, &server, &ses, &tcon);
4893 if (rc)
4894 goto error;
4895 }
4896
4897 kfree(root_path);
4898 root_path = build_unc_path_to_root(vol, cifs_sb, false);
4899 if (IS_ERR(root_path)) {
4900 rc = PTR_ERR(root_path);
4901 root_path = NULL;
4902 goto error;
4903 }
4904 /* Cache out resolved root server */
4905 (void)dfs_cache_find(xid, ses, cifs_sb->local_nls, cifs_remap(cifs_sb),
4906 root_path + 1, NULL, NULL);
4907 kfree(root_path);
4908 root_path = NULL;
4909
4910 set_root_tcon(cifs_sb, tcon, &root_tcon);
4911
4912 for (count = 1; ;) {
4913 if (!rc && tcon) {
4914 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
4915 if (!rc || rc != -EREMOTE)
4916 break;
4917 }
4918 /*
4919 * BB: when we implement proper loop detection,
4920 * we will remove this check. But now we need it
4921 * to prevent an indefinite loop if 'DFS tree' is
4922 * misconfigured (i.e. has loops).
4923 */
4924 if (count++ > MAX_NESTED_LINKS) {
4925 rc = -ELOOP;
4926 break;
4927 }
4928
4929 kfree(full_path);
4930 full_path = build_unc_path_to_root(vol, cifs_sb, true);
4931 if (IS_ERR(full_path)) {
4932 rc = PTR_ERR(full_path);
4933 full_path = NULL;
4934 break;
4935 }
4936
4937 old_mountdata = cifs_sb->mountdata;
4938 rc = expand_dfs_referral(xid, root_tcon->ses, vol, cifs_sb,
4939 true);
4940 if (rc)
4941 break;
4942
4943 if (cifs_sb->mountdata != old_mountdata) {
4944 mount_put_conns(cifs_sb, xid, server, ses, tcon);
4945 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses,
4946 &tcon);
4947 /*
4948 * Ensure that DFS referrals go through new root server.
4949 */
4950 if (!rc && tcon &&
4951 (tcon->share_flags & (SHI1005_FLAGS_DFS |
4952 SHI1005_FLAGS_DFS_ROOT))) {
4953 cifs_put_tcon(root_tcon);
4954 set_root_tcon(cifs_sb, tcon, &root_tcon);
4955 }
4956 }
4957 if (rc) {
4958 if (rc == -EACCES || rc == -EOPNOTSUPP)
4959 break;
4960 /* Perform DFS failover to any other DFS targets */
4961 rc = mount_do_dfs_failover(full_path + 1, cifs_sb, vol,
4962 root_tcon->ses, &xid,
4963 &server, &ses, &tcon);
4964 if (rc == -EACCES || rc == -EOPNOTSUPP || !server ||
4965 !ses)
4966 goto error;
4967 }
4968 }
4969 cifs_put_tcon(root_tcon);
4970
4971 if (rc)
4972 goto error;
4973
4974 spin_lock(&cifs_tcp_ses_lock);
4975 if (!tcon->dfs_path) {
4976 /* Save full path in new tcon to do failover when reconnecting tcons */
4977 tcon->dfs_path = full_path;
4978 full_path = NULL;
4979 tcon->remap = cifs_remap(cifs_sb);
4980 }
4981 cifs_sb->origin_fullpath = kstrndup(tcon->dfs_path,
4982 strlen(tcon->dfs_path),
4983 GFP_ATOMIC);
4984 if (!cifs_sb->origin_fullpath) {
4985 spin_unlock(&cifs_tcp_ses_lock);
4986 rc = -ENOMEM;
4987 goto error;
4988 }
4989 spin_unlock(&cifs_tcp_ses_lock);
4990
4991 rc = dfs_cache_add_vol(origin_mountdata, vol, cifs_sb->origin_fullpath);
4992 if (rc) {
4993 kfree(cifs_sb->origin_fullpath);
4994 goto error;
4995 }
4996 /*
4997 * After reconnecting to a different server, unique ids won't
4998 * match anymore, so we disable serverino. This prevents
4999 * dentry revalidation to think the dentry are stale (ESTALE).
5000 */
5001 cifs_autodisable_serverino(cifs_sb);
5002 out:
5003 free_xid(xid);
5004 cifs_try_adding_channels(ses);
5005 return mount_setup_tlink(cifs_sb, ses, tcon);
5006
5007 error:
5008 kfree(full_path);
5009 kfree(root_path);
5010 kfree(origin_mountdata);
5011 mount_put_conns(cifs_sb, xid, server, ses, tcon);
5012 return rc;
5013 }
5014 #else
5015 int cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *vol)
5016 {
5017 int rc = 0;
5018 unsigned int xid;
5019 struct cifs_ses *ses;
5020 struct cifs_tcon *tcon;
5021 struct TCP_Server_Info *server;
5022
5023 rc = mount_get_conns(vol, cifs_sb, &xid, &server, &ses, &tcon);
5024 if (rc)
5025 goto error;
5026
5027 if (tcon) {
5028 rc = is_path_remote(cifs_sb, vol, xid, server, tcon);
5029 if (rc == -EREMOTE)
5030 rc = -EOPNOTSUPP;
5031 if (rc)
5032 goto error;
5033 }
5034
5035 free_xid(xid);
5036
5037 return mount_setup_tlink(cifs_sb, ses, tcon);
5038
5039 error:
5040 mount_put_conns(cifs_sb, xid, server, ses, tcon);
5041 return rc;
5042 }
5043 #endif
5044
5045 /*
5046 * Issue a TREE_CONNECT request.
5047 */
5048 int
5049 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
5050 const char *tree, struct cifs_tcon *tcon,
5051 const struct nls_table *nls_codepage)
5052 {
5053 struct smb_hdr *smb_buffer;
5054 struct smb_hdr *smb_buffer_response;
5055 TCONX_REQ *pSMB;
5056 TCONX_RSP *pSMBr;
5057 unsigned char *bcc_ptr;
5058 int rc = 0;
5059 int length;
5060 __u16 bytes_left, count;
5061
5062 if (ses == NULL)
5063 return -EIO;
5064
5065 smb_buffer = cifs_buf_get();
5066 if (smb_buffer == NULL)
5067 return -ENOMEM;
5068
5069 smb_buffer_response = smb_buffer;
5070
5071 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
5072 NULL /*no tid */ , 4 /*wct */ );
5073
5074 smb_buffer->Mid = get_next_mid(ses->server);
5075 smb_buffer->Uid = ses->Suid;
5076 pSMB = (TCONX_REQ *) smb_buffer;
5077 pSMBr = (TCONX_RSP *) smb_buffer_response;
5078
5079 pSMB->AndXCommand = 0xFF;
5080 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
5081 bcc_ptr = &pSMB->Password[0];
5082 if (tcon->pipe || (ses->server->sec_mode & SECMODE_USER)) {
5083 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
5084 *bcc_ptr = 0; /* password is null byte */
5085 bcc_ptr++; /* skip password */
5086 /* already aligned so no need to do it below */
5087 } else {
5088 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
5089 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
5090 specified as required (when that support is added to
5091 the vfs in the future) as only NTLM or the much
5092 weaker LANMAN (which we do not send by default) is accepted
5093 by Samba (not sure whether other servers allow
5094 NTLMv2 password here) */
5095 #ifdef CONFIG_CIFS_WEAK_PW_HASH
5096 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
5097 (ses->sectype == LANMAN))
5098 calc_lanman_hash(tcon->password, ses->server->cryptkey,
5099 ses->server->sec_mode &
5100 SECMODE_PW_ENCRYPT ? true : false,
5101 bcc_ptr);
5102 else
5103 #endif /* CIFS_WEAK_PW_HASH */
5104 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
5105 bcc_ptr, nls_codepage);
5106 if (rc) {
5107 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
5108 __func__, rc);
5109 cifs_buf_release(smb_buffer);
5110 return rc;
5111 }
5112
5113 bcc_ptr += CIFS_AUTH_RESP_SIZE;
5114 if (ses->capabilities & CAP_UNICODE) {
5115 /* must align unicode strings */
5116 *bcc_ptr = 0; /* null byte password */
5117 bcc_ptr++;
5118 }
5119 }
5120
5121 if (ses->server->sign)
5122 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
5123
5124 if (ses->capabilities & CAP_STATUS32) {
5125 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
5126 }
5127 if (ses->capabilities & CAP_DFS) {
5128 smb_buffer->Flags2 |= SMBFLG2_DFS;
5129 }
5130 if (ses->capabilities & CAP_UNICODE) {
5131 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
5132 length =
5133 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
5134 6 /* max utf8 char length in bytes */ *
5135 (/* server len*/ + 256 /* share len */), nls_codepage);
5136 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
5137 bcc_ptr += 2; /* skip trailing null */
5138 } else { /* ASCII */
5139 strcpy(bcc_ptr, tree);
5140 bcc_ptr += strlen(tree) + 1;
5141 }
5142 strcpy(bcc_ptr, "?????");
5143 bcc_ptr += strlen("?????");
5144 bcc_ptr += 1;
5145 count = bcc_ptr - &pSMB->Password[0];
5146 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
5147 pSMB->hdr.smb_buf_length) + count);
5148 pSMB->ByteCount = cpu_to_le16(count);
5149
5150 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
5151 0);
5152
5153 /* above now done in SendReceive */
5154 if (rc == 0) {
5155 bool is_unicode;
5156
5157 tcon->tidStatus = CifsGood;
5158 tcon->need_reconnect = false;
5159 tcon->tid = smb_buffer_response->Tid;
5160 bcc_ptr = pByteArea(smb_buffer_response);
5161 bytes_left = get_bcc(smb_buffer_response);
5162 length = strnlen(bcc_ptr, bytes_left - 2);
5163 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
5164 is_unicode = true;
5165 else
5166 is_unicode = false;
5167
5168
5169 /* skip service field (NB: this field is always ASCII) */
5170 if (length == 3) {
5171 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
5172 (bcc_ptr[2] == 'C')) {
5173 cifs_dbg(FYI, "IPC connection\n");
5174 tcon->ipc = true;
5175 tcon->pipe = true;
5176 }
5177 } else if (length == 2) {
5178 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
5179 /* the most common case */
5180 cifs_dbg(FYI, "disk share connection\n");
5181 }
5182 }
5183 bcc_ptr += length + 1;
5184 bytes_left -= (length + 1);
5185 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
5186
5187 /* mostly informational -- no need to fail on error here */
5188 kfree(tcon->nativeFileSystem);
5189 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
5190 bytes_left, is_unicode,
5191 nls_codepage);
5192
5193 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
5194
5195 if ((smb_buffer_response->WordCount == 3) ||
5196 (smb_buffer_response->WordCount == 7))
5197 /* field is in same location */
5198 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
5199 else
5200 tcon->Flags = 0;
5201 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
5202 }
5203
5204 cifs_buf_release(smb_buffer);
5205 return rc;
5206 }
5207
5208 static void delayed_free(struct rcu_head *p)
5209 {
5210 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
5211 unload_nls(sbi->local_nls);
5212 kfree(sbi);
5213 }
5214
5215 void
5216 cifs_umount(struct cifs_sb_info *cifs_sb)
5217 {
5218 struct rb_root *root = &cifs_sb->tlink_tree;
5219 struct rb_node *node;
5220 struct tcon_link *tlink;
5221
5222 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
5223
5224 spin_lock(&cifs_sb->tlink_tree_lock);
5225 while ((node = rb_first(root))) {
5226 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5227 cifs_get_tlink(tlink);
5228 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5229 rb_erase(node, root);
5230
5231 spin_unlock(&cifs_sb->tlink_tree_lock);
5232 cifs_put_tlink(tlink);
5233 spin_lock(&cifs_sb->tlink_tree_lock);
5234 }
5235 spin_unlock(&cifs_sb->tlink_tree_lock);
5236
5237 kfree(cifs_sb->mountdata);
5238 kfree(cifs_sb->prepath);
5239 #ifdef CONFIG_CIFS_DFS_UPCALL
5240 dfs_cache_del_vol(cifs_sb->origin_fullpath);
5241 kfree(cifs_sb->origin_fullpath);
5242 #endif
5243 call_rcu(&cifs_sb->rcu, delayed_free);
5244 }
5245
5246 int
5247 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
5248 {
5249 int rc = 0;
5250 struct TCP_Server_Info *server = cifs_ses_server(ses);
5251
5252 if (!server->ops->need_neg || !server->ops->negotiate)
5253 return -ENOSYS;
5254
5255 /* only send once per connect */
5256 if (!server->ops->need_neg(server))
5257 return 0;
5258
5259 rc = server->ops->negotiate(xid, ses);
5260 if (rc == 0) {
5261 spin_lock(&GlobalMid_Lock);
5262 if (server->tcpStatus == CifsNeedNegotiate)
5263 server->tcpStatus = CifsGood;
5264 else
5265 rc = -EHOSTDOWN;
5266 spin_unlock(&GlobalMid_Lock);
5267 }
5268
5269 return rc;
5270 }
5271
5272 int
5273 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
5274 struct nls_table *nls_info)
5275 {
5276 int rc = -ENOSYS;
5277 struct TCP_Server_Info *server = cifs_ses_server(ses);
5278
5279 if (!ses->binding) {
5280 ses->capabilities = server->capabilities;
5281 if (linuxExtEnabled == 0)
5282 ses->capabilities &= (~server->vals->cap_unix);
5283
5284 if (ses->auth_key.response) {
5285 cifs_dbg(FYI, "Free previous auth_key.response = %p\n",
5286 ses->auth_key.response);
5287 kfree(ses->auth_key.response);
5288 ses->auth_key.response = NULL;
5289 ses->auth_key.len = 0;
5290 }
5291 }
5292
5293 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
5294 server->sec_mode, server->capabilities, server->timeAdj);
5295
5296 if (server->ops->sess_setup)
5297 rc = server->ops->sess_setup(xid, ses, nls_info);
5298
5299 if (rc)
5300 cifs_server_dbg(VFS, "Send error in SessSetup = %d\n", rc);
5301
5302 return rc;
5303 }
5304
5305 static int
5306 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
5307 {
5308 vol->sectype = ses->sectype;
5309
5310 /* krb5 is special, since we don't need username or pw */
5311 if (vol->sectype == Kerberos)
5312 return 0;
5313
5314 return cifs_set_cifscreds(vol, ses);
5315 }
5316
5317 static struct cifs_tcon *
5318 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
5319 {
5320 int rc;
5321 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
5322 struct cifs_ses *ses;
5323 struct cifs_tcon *tcon = NULL;
5324 struct smb_vol *vol_info;
5325
5326 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
5327 if (vol_info == NULL)
5328 return ERR_PTR(-ENOMEM);
5329
5330 vol_info->local_nls = cifs_sb->local_nls;
5331 vol_info->linux_uid = fsuid;
5332 vol_info->cred_uid = fsuid;
5333 vol_info->UNC = master_tcon->treeName;
5334 vol_info->retry = master_tcon->retry;
5335 vol_info->nocase = master_tcon->nocase;
5336 vol_info->nohandlecache = master_tcon->nohandlecache;
5337 vol_info->local_lease = master_tcon->local_lease;
5338 vol_info->no_linux_ext = !master_tcon->unix_ext;
5339 vol_info->sectype = master_tcon->ses->sectype;
5340 vol_info->sign = master_tcon->ses->sign;
5341
5342 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
5343 if (rc) {
5344 tcon = ERR_PTR(rc);
5345 goto out;
5346 }
5347
5348 /* get a reference for the same TCP session */
5349 spin_lock(&cifs_tcp_ses_lock);
5350 ++master_tcon->ses->server->srv_count;
5351 spin_unlock(&cifs_tcp_ses_lock);
5352
5353 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
5354 if (IS_ERR(ses)) {
5355 tcon = (struct cifs_tcon *)ses;
5356 cifs_put_tcp_session(master_tcon->ses->server, 0);
5357 goto out;
5358 }
5359
5360 tcon = cifs_get_tcon(ses, vol_info);
5361 if (IS_ERR(tcon)) {
5362 cifs_put_smb_ses(ses);
5363 goto out;
5364 }
5365
5366 /* if new SMB3.11 POSIX extensions are supported do not remap / and \ */
5367 if (tcon->posix_extensions)
5368 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_POSIX_PATHS;
5369
5370 if (cap_unix(ses))
5371 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
5372
5373 out:
5374 kfree(vol_info->username);
5375 kzfree(vol_info->password);
5376 kfree(vol_info);
5377
5378 return tcon;
5379 }
5380
5381 struct cifs_tcon *
5382 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
5383 {
5384 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
5385 }
5386
5387 /* find and return a tlink with given uid */
5388 static struct tcon_link *
5389 tlink_rb_search(struct rb_root *root, kuid_t uid)
5390 {
5391 struct rb_node *node = root->rb_node;
5392 struct tcon_link *tlink;
5393
5394 while (node) {
5395 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
5396
5397 if (uid_gt(tlink->tl_uid, uid))
5398 node = node->rb_left;
5399 else if (uid_lt(tlink->tl_uid, uid))
5400 node = node->rb_right;
5401 else
5402 return tlink;
5403 }
5404 return NULL;
5405 }
5406
5407 /* insert a tcon_link into the tree */
5408 static void
5409 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
5410 {
5411 struct rb_node **new = &(root->rb_node), *parent = NULL;
5412 struct tcon_link *tlink;
5413
5414 while (*new) {
5415 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
5416 parent = *new;
5417
5418 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
5419 new = &((*new)->rb_left);
5420 else
5421 new = &((*new)->rb_right);
5422 }
5423
5424 rb_link_node(&new_tlink->tl_rbnode, parent, new);
5425 rb_insert_color(&new_tlink->tl_rbnode, root);
5426 }
5427
5428 /*
5429 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
5430 * current task.
5431 *
5432 * If the superblock doesn't refer to a multiuser mount, then just return
5433 * the master tcon for the mount.
5434 *
5435 * First, search the rbtree for an existing tcon for this fsuid. If one
5436 * exists, then check to see if it's pending construction. If it is then wait
5437 * for construction to complete. Once it's no longer pending, check to see if
5438 * it failed and either return an error or retry construction, depending on
5439 * the timeout.
5440 *
5441 * If one doesn't exist then insert a new tcon_link struct into the tree and
5442 * try to construct a new one.
5443 */
5444 struct tcon_link *
5445 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
5446 {
5447 int ret;
5448 kuid_t fsuid = current_fsuid();
5449 struct tcon_link *tlink, *newtlink;
5450
5451 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
5452 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
5453
5454 spin_lock(&cifs_sb->tlink_tree_lock);
5455 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5456 if (tlink)
5457 cifs_get_tlink(tlink);
5458 spin_unlock(&cifs_sb->tlink_tree_lock);
5459
5460 if (tlink == NULL) {
5461 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
5462 if (newtlink == NULL)
5463 return ERR_PTR(-ENOMEM);
5464 newtlink->tl_uid = fsuid;
5465 newtlink->tl_tcon = ERR_PTR(-EACCES);
5466 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
5467 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
5468 cifs_get_tlink(newtlink);
5469
5470 spin_lock(&cifs_sb->tlink_tree_lock);
5471 /* was one inserted after previous search? */
5472 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
5473 if (tlink) {
5474 cifs_get_tlink(tlink);
5475 spin_unlock(&cifs_sb->tlink_tree_lock);
5476 kfree(newtlink);
5477 goto wait_for_construction;
5478 }
5479 tlink = newtlink;
5480 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
5481 spin_unlock(&cifs_sb->tlink_tree_lock);
5482 } else {
5483 wait_for_construction:
5484 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
5485 TASK_INTERRUPTIBLE);
5486 if (ret) {
5487 cifs_put_tlink(tlink);
5488 return ERR_PTR(-ERESTARTSYS);
5489 }
5490
5491 /* if it's good, return it */
5492 if (!IS_ERR(tlink->tl_tcon))
5493 return tlink;
5494
5495 /* return error if we tried this already recently */
5496 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
5497 cifs_put_tlink(tlink);
5498 return ERR_PTR(-EACCES);
5499 }
5500
5501 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
5502 goto wait_for_construction;
5503 }
5504
5505 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
5506 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
5507 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
5508
5509 if (IS_ERR(tlink->tl_tcon)) {
5510 cifs_put_tlink(tlink);
5511 return ERR_PTR(-EACCES);
5512 }
5513
5514 return tlink;
5515 }
5516
5517 /*
5518 * periodic workqueue job that scans tcon_tree for a superblock and closes
5519 * out tcons.
5520 */
5521 static void
5522 cifs_prune_tlinks(struct work_struct *work)
5523 {
5524 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
5525 prune_tlinks.work);
5526 struct rb_root *root = &cifs_sb->tlink_tree;
5527 struct rb_node *node;
5528 struct rb_node *tmp;
5529 struct tcon_link *tlink;
5530
5531 /*
5532 * Because we drop the spinlock in the loop in order to put the tlink
5533 * it's not guarded against removal of links from the tree. The only
5534 * places that remove entries from the tree are this function and
5535 * umounts. Because this function is non-reentrant and is canceled
5536 * before umount can proceed, this is safe.
5537 */
5538 spin_lock(&cifs_sb->tlink_tree_lock);
5539 node = rb_first(root);
5540 while (node != NULL) {
5541 tmp = node;
5542 node = rb_next(tmp);
5543 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
5544
5545 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
5546 atomic_read(&tlink->tl_count) != 0 ||
5547 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
5548 continue;
5549
5550 cifs_get_tlink(tlink);
5551 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
5552 rb_erase(tmp, root);
5553
5554 spin_unlock(&cifs_sb->tlink_tree_lock);
5555 cifs_put_tlink(tlink);
5556 spin_lock(&cifs_sb->tlink_tree_lock);
5557 }
5558 spin_unlock(&cifs_sb->tlink_tree_lock);
5559
5560 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
5561 TLINK_IDLE_EXPIRE);
5562 }
Ubuntu Hirsute Linux kernel mirror