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