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