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