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