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/list.h>
25#include <linux/wait.h>
26#include <linux/slab.h>
27#include <linux/pagemap.h>
28#include <linux/ctype.h>
29#include <linux/utsname.h>
30#include <linux/mempool.h>
31#include <linux/delay.h>
32#include <linux/completion.h>
33#include <linux/kthread.h>
34#include <linux/pagevec.h>
35#include <linux/freezer.h>
36#include <linux/namei.h>
37#include <asm/uaccess.h>
38#include <asm/processor.h>
39#include <linux/inet.h>
40#include <linux/module.h>
41#include <keys/user-type.h>
42#include <net/ipv6.h>
43#include <linux/parser.h>
44
45#include "cifspdu.h"
46#include "cifsglob.h"
47#include "cifsproto.h"
48#include "cifs_unicode.h"
49#include "cifs_debug.h"
50#include "cifs_fs_sb.h"
51#include "ntlmssp.h"
52#include "nterr.h"
53#include "rfc1002pdu.h"
54#include "fscache.h"
55
56#define CIFS_PORT 445
57#define RFC1001_PORT 139
58
59extern mempool_t *cifs_req_poolp;
60
61
62#define TLINK_ERROR_EXPIRE (1 * HZ)
63#define TLINK_IDLE_EXPIRE (600 * HZ)
64
65enum {
66
67 Opt_user_xattr, Opt_nouser_xattr,
68 Opt_forceuid, Opt_noforceuid,
69 Opt_forcegid, Opt_noforcegid,
70 Opt_noblocksend, Opt_noautotune,
71 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
72 Opt_mapposix, Opt_nomapposix,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
76 Opt_nocase,
77 Opt_brl, Opt_nobrl,
78 Opt_forcemandatorylock, Opt_setuidfromacl, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
81 Opt_nointr, Opt_intr,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
86 Opt_sign, Opt_seal, Opt_noac,
87 Opt_fsc, Opt_mfsymlinks,
88 Opt_multiuser, Opt_sloppy, Opt_nosharesock,
89 Opt_persistent, Opt_nopersistent,
90 Opt_resilient, Opt_noresilient,
91
92
93 Opt_backupuid, Opt_backupgid, Opt_uid,
94 Opt_cruid, Opt_gid, Opt_file_mode,
95 Opt_dirmode, Opt_port,
96 Opt_rsize, Opt_wsize, Opt_actimeo,
97 Opt_echo_interval, Opt_max_credits,
98
99
100 Opt_user, Opt_pass, Opt_ip,
101 Opt_domain, Opt_srcaddr, Opt_iocharset,
102 Opt_netbiosname, Opt_servern,
103 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
104
105
106 Opt_ignore,
107
108
109 Opt_blank_pass,
110 Opt_blank_user,
111 Opt_blank_ip,
112
113 Opt_err
114};
115
116static const match_table_t cifs_mount_option_tokens = {
117
118 { Opt_user_xattr, "user_xattr" },
119 { Opt_nouser_xattr, "nouser_xattr" },
120 { Opt_forceuid, "forceuid" },
121 { Opt_noforceuid, "noforceuid" },
122 { Opt_forcegid, "forcegid" },
123 { Opt_noforcegid, "noforcegid" },
124 { Opt_noblocksend, "noblocksend" },
125 { Opt_noautotune, "noautotune" },
126 { Opt_hard, "hard" },
127 { Opt_soft, "soft" },
128 { Opt_perm, "perm" },
129 { Opt_noperm, "noperm" },
130 { Opt_mapchars, "mapchars" },
131 { Opt_nomapchars, "nomapchars" },
132 { Opt_mapposix, "mapposix" },
133 { Opt_nomapposix, "nomapposix" },
134 { Opt_sfu, "sfu" },
135 { Opt_nosfu, "nosfu" },
136 { Opt_nodfs, "nodfs" },
137 { Opt_posixpaths, "posixpaths" },
138 { Opt_noposixpaths, "noposixpaths" },
139 { Opt_nounix, "nounix" },
140 { Opt_nounix, "nolinux" },
141 { Opt_nocase, "nocase" },
142 { Opt_nocase, "ignorecase" },
143 { Opt_brl, "brl" },
144 { Opt_nobrl, "nobrl" },
145 { Opt_nobrl, "nolock" },
146 { Opt_forcemandatorylock, "forcemandatorylock" },
147 { Opt_forcemandatorylock, "forcemand" },
148 { Opt_setuids, "setuids" },
149 { Opt_nosetuids, "nosetuids" },
150 { Opt_setuidfromacl, "idsfromsid" },
151 { Opt_dynperm, "dynperm" },
152 { Opt_nodynperm, "nodynperm" },
153 { Opt_nohard, "nohard" },
154 { Opt_nosoft, "nosoft" },
155 { Opt_nointr, "nointr" },
156 { Opt_intr, "intr" },
157 { Opt_nostrictsync, "nostrictsync" },
158 { Opt_strictsync, "strictsync" },
159 { Opt_serverino, "serverino" },
160 { Opt_noserverino, "noserverino" },
161 { Opt_rwpidforward, "rwpidforward" },
162 { Opt_cifsacl, "cifsacl" },
163 { Opt_nocifsacl, "nocifsacl" },
164 { Opt_acl, "acl" },
165 { Opt_noacl, "noacl" },
166 { Opt_locallease, "locallease" },
167 { Opt_sign, "sign" },
168 { Opt_seal, "seal" },
169 { Opt_noac, "noac" },
170 { Opt_fsc, "fsc" },
171 { Opt_mfsymlinks, "mfsymlinks" },
172 { Opt_multiuser, "multiuser" },
173 { Opt_sloppy, "sloppy" },
174 { Opt_nosharesock, "nosharesock" },
175 { Opt_persistent, "persistenthandles"},
176 { Opt_nopersistent, "nopersistenthandles"},
177 { Opt_resilient, "resilienthandles"},
178 { Opt_noresilient, "noresilienthandles"},
179
180 { Opt_backupuid, "backupuid=%s" },
181 { Opt_backupgid, "backupgid=%s" },
182 { Opt_uid, "uid=%s" },
183 { Opt_cruid, "cruid=%s" },
184 { Opt_gid, "gid=%s" },
185 { Opt_file_mode, "file_mode=%s" },
186 { Opt_dirmode, "dirmode=%s" },
187 { Opt_dirmode, "dir_mode=%s" },
188 { Opt_port, "port=%s" },
189 { Opt_rsize, "rsize=%s" },
190 { Opt_wsize, "wsize=%s" },
191 { Opt_actimeo, "actimeo=%s" },
192 { Opt_echo_interval, "echo_interval=%s" },
193 { Opt_max_credits, "max_credits=%s" },
194
195 { Opt_blank_user, "user=" },
196 { Opt_blank_user, "username=" },
197 { Opt_user, "user=%s" },
198 { Opt_user, "username=%s" },
199 { Opt_blank_pass, "pass=" },
200 { Opt_blank_pass, "password=" },
201 { Opt_pass, "pass=%s" },
202 { Opt_pass, "password=%s" },
203 { Opt_blank_ip, "ip=" },
204 { Opt_blank_ip, "addr=" },
205 { Opt_ip, "ip=%s" },
206 { Opt_ip, "addr=%s" },
207 { Opt_ignore, "unc=%s" },
208 { Opt_ignore, "target=%s" },
209 { Opt_ignore, "path=%s" },
210 { Opt_domain, "dom=%s" },
211 { Opt_domain, "domain=%s" },
212 { Opt_domain, "workgroup=%s" },
213 { Opt_srcaddr, "srcaddr=%s" },
214 { Opt_ignore, "prefixpath=%s" },
215 { Opt_iocharset, "iocharset=%s" },
216 { Opt_netbiosname, "netbiosname=%s" },
217 { Opt_servern, "servern=%s" },
218 { Opt_ver, "ver=%s" },
219 { Opt_vers, "vers=%s" },
220 { Opt_sec, "sec=%s" },
221 { Opt_cache, "cache=%s" },
222
223 { Opt_ignore, "cred" },
224 { Opt_ignore, "credentials" },
225 { Opt_ignore, "cred=%s" },
226 { Opt_ignore, "credentials=%s" },
227 { Opt_ignore, "guest" },
228 { Opt_ignore, "rw" },
229 { Opt_ignore, "ro" },
230 { Opt_ignore, "suid" },
231 { Opt_ignore, "nosuid" },
232 { Opt_ignore, "exec" },
233 { Opt_ignore, "noexec" },
234 { Opt_ignore, "nodev" },
235 { Opt_ignore, "noauto" },
236 { Opt_ignore, "dev" },
237 { Opt_ignore, "mand" },
238 { Opt_ignore, "nomand" },
239 { Opt_ignore, "_netdev" },
240
241 { Opt_err, NULL }
242};
243
244enum {
245 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
246 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
247 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
248 Opt_sec_ntlmv2i, Opt_sec_lanman,
249 Opt_sec_none,
250
251 Opt_sec_err
252};
253
254static const match_table_t cifs_secflavor_tokens = {
255 { Opt_sec_krb5, "krb5" },
256 { Opt_sec_krb5i, "krb5i" },
257 { Opt_sec_krb5p, "krb5p" },
258 { Opt_sec_ntlmsspi, "ntlmsspi" },
259 { Opt_sec_ntlmssp, "ntlmssp" },
260 { Opt_ntlm, "ntlm" },
261 { Opt_sec_ntlmi, "ntlmi" },
262 { Opt_sec_ntlmv2, "nontlm" },
263 { Opt_sec_ntlmv2, "ntlmv2" },
264 { Opt_sec_ntlmv2i, "ntlmv2i" },
265 { Opt_sec_lanman, "lanman" },
266 { Opt_sec_none, "none" },
267
268 { Opt_sec_err, NULL }
269};
270
271
272enum {
273 Opt_cache_loose,
274 Opt_cache_strict,
275 Opt_cache_none,
276 Opt_cache_err
277};
278
279static const match_table_t cifs_cacheflavor_tokens = {
280 { Opt_cache_loose, "loose" },
281 { Opt_cache_strict, "strict" },
282 { Opt_cache_none, "none" },
283 { Opt_cache_err, NULL }
284};
285
286static const match_table_t cifs_smb_version_tokens = {
287 { Smb_1, SMB1_VERSION_STRING },
288 { Smb_20, SMB20_VERSION_STRING},
289 { Smb_21, SMB21_VERSION_STRING },
290 { Smb_30, SMB30_VERSION_STRING },
291 { Smb_302, SMB302_VERSION_STRING },
292#ifdef CONFIG_CIFS_SMB311
293 { Smb_311, SMB311_VERSION_STRING },
294 { Smb_311, ALT_SMB311_VERSION_STRING },
295#endif
296 { Smb_version_err, NULL }
297};
298
299static int ip_connect(struct TCP_Server_Info *server);
300static int generic_ip_connect(struct TCP_Server_Info *server);
301static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
302static void cifs_prune_tlinks(struct work_struct *work);
303static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
304 const char *devname);
305
306
307
308
309
310
311
312
313
314int
315cifs_reconnect(struct TCP_Server_Info *server)
316{
317 int rc = 0;
318 struct list_head *tmp, *tmp2;
319 struct cifs_ses *ses;
320 struct cifs_tcon *tcon;
321 struct mid_q_entry *mid_entry;
322 struct list_head retry_list;
323
324 spin_lock(&GlobalMid_Lock);
325 if (server->tcpStatus == CifsExiting) {
326
327
328 spin_unlock(&GlobalMid_Lock);
329 return rc;
330 } else
331 server->tcpStatus = CifsNeedReconnect;
332 spin_unlock(&GlobalMid_Lock);
333 server->maxBuf = 0;
334#ifdef CONFIG_CIFS_SMB2
335 server->max_read = 0;
336#endif
337
338 cifs_dbg(FYI, "Reconnecting tcp session\n");
339
340
341
342 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n",
343 __func__);
344 spin_lock(&cifs_tcp_ses_lock);
345 list_for_each(tmp, &server->smb_ses_list) {
346 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
347 ses->need_reconnect = true;
348 ses->ipc_tid = 0;
349 list_for_each(tmp2, &ses->tcon_list) {
350 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
351 tcon->need_reconnect = true;
352 }
353 }
354 spin_unlock(&cifs_tcp_ses_lock);
355
356
357 cifs_dbg(FYI, "%s: tearing down socket\n", __func__);
358 mutex_lock(&server->srv_mutex);
359 if (server->ssocket) {
360 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n",
361 server->ssocket->state, server->ssocket->flags);
362 kernel_sock_shutdown(server->ssocket, SHUT_WR);
363 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n",
364 server->ssocket->state, server->ssocket->flags);
365 sock_release(server->ssocket);
366 server->ssocket = NULL;
367 }
368 server->sequence_number = 0;
369 server->session_estab = false;
370 kfree(server->session_key.response);
371 server->session_key.response = NULL;
372 server->session_key.len = 0;
373 server->lstrp = jiffies;
374
375
376 INIT_LIST_HEAD(&retry_list);
377 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
378 spin_lock(&GlobalMid_Lock);
379 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
380 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
381 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
382 mid_entry->mid_state = MID_RETRY_NEEDED;
383 list_move(&mid_entry->qhead, &retry_list);
384 }
385 spin_unlock(&GlobalMid_Lock);
386 mutex_unlock(&server->srv_mutex);
387
388 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__);
389 list_for_each_safe(tmp, tmp2, &retry_list) {
390 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
391 list_del_init(&mid_entry->qhead);
392 mid_entry->callback(mid_entry);
393 }
394
395 do {
396 try_to_freeze();
397
398
399 mutex_lock(&server->srv_mutex);
400 rc = generic_ip_connect(server);
401 if (rc) {
402 cifs_dbg(FYI, "reconnect error %d\n", rc);
403 mutex_unlock(&server->srv_mutex);
404 msleep(3000);
405 } else {
406 atomic_inc(&tcpSesReconnectCount);
407 spin_lock(&GlobalMid_Lock);
408 if (server->tcpStatus != CifsExiting)
409 server->tcpStatus = CifsNeedNegotiate;
410 spin_unlock(&GlobalMid_Lock);
411 mutex_unlock(&server->srv_mutex);
412 }
413 } while (server->tcpStatus == CifsNeedReconnect);
414
415 if (server->tcpStatus == CifsNeedNegotiate)
416 mod_delayed_work(cifsiod_wq, &server->echo, 0);
417
418 return rc;
419}
420
421static void
422cifs_echo_request(struct work_struct *work)
423{
424 int rc;
425 struct TCP_Server_Info *server = container_of(work,
426 struct TCP_Server_Info, echo.work);
427 unsigned long echo_interval;
428
429
430
431
432
433 if (server->tcpStatus == CifsNeedNegotiate)
434 echo_interval = 0;
435 else
436 echo_interval = server->echo_interval;
437
438
439
440
441
442
443 if (server->tcpStatus == CifsNeedReconnect ||
444 server->tcpStatus == CifsExiting ||
445 server->tcpStatus == CifsNew ||
446 (server->ops->can_echo && !server->ops->can_echo(server)) ||
447 time_before(jiffies, server->lstrp + echo_interval - HZ))
448 goto requeue_echo;
449
450 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
451 if (rc)
452 cifs_dbg(FYI, "Unable to send echo request to server: %s\n",
453 server->hostname);
454
455requeue_echo:
456 queue_delayed_work(cifsiod_wq, &server->echo, server->echo_interval);
457}
458
459static bool
460allocate_buffers(struct TCP_Server_Info *server)
461{
462 if (!server->bigbuf) {
463 server->bigbuf = (char *)cifs_buf_get();
464 if (!server->bigbuf) {
465 cifs_dbg(VFS, "No memory for large SMB response\n");
466 msleep(3000);
467
468 return false;
469 }
470 } else if (server->large_buf) {
471
472 memset(server->bigbuf, 0, HEADER_SIZE(server));
473 }
474
475 if (!server->smallbuf) {
476 server->smallbuf = (char *)cifs_small_buf_get();
477 if (!server->smallbuf) {
478 cifs_dbg(VFS, "No memory for SMB response\n");
479 msleep(1000);
480
481 return false;
482 }
483
484 } else {
485
486 memset(server->smallbuf, 0, HEADER_SIZE(server));
487 }
488
489 return true;
490}
491
492static bool
493server_unresponsive(struct TCP_Server_Info *server)
494{
495
496
497
498
499
500
501
502
503
504
505
506 if (server->tcpStatus == CifsGood &&
507 time_after(jiffies, server->lstrp + 2 * server->echo_interval)) {
508 cifs_dbg(VFS, "Server %s has not responded in %lu seconds. Reconnecting...\n",
509 server->hostname, (2 * server->echo_interval) / HZ);
510 cifs_reconnect(server);
511 wake_up(&server->response_q);
512 return true;
513 }
514
515 return false;
516}
517
518static int
519cifs_readv_from_socket(struct TCP_Server_Info *server, struct msghdr *smb_msg)
520{
521 int length = 0;
522 int total_read;
523
524 smb_msg->msg_control = NULL;
525 smb_msg->msg_controllen = 0;
526
527 for (total_read = 0; msg_data_left(smb_msg); total_read += length) {
528 try_to_freeze();
529
530 if (server_unresponsive(server))
531 return -ECONNABORTED;
532
533 length = sock_recvmsg(server->ssocket, smb_msg, 0);
534
535 if (server->tcpStatus == CifsExiting)
536 return -ESHUTDOWN;
537
538 if (server->tcpStatus == CifsNeedReconnect) {
539 cifs_reconnect(server);
540 return -ECONNABORTED;
541 }
542
543 if (length == -ERESTARTSYS ||
544 length == -EAGAIN ||
545 length == -EINTR) {
546
547
548
549
550
551 usleep_range(1000, 2000);
552 length = 0;
553 continue;
554 }
555
556 if (length <= 0) {
557 cifs_dbg(FYI, "Received no data or error: %d\n", length);
558 cifs_reconnect(server);
559 return -ECONNABORTED;
560 }
561 }
562 return total_read;
563}
564
565int
566cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
567 unsigned int to_read)
568{
569 struct msghdr smb_msg;
570 struct kvec iov = {.iov_base = buf, .iov_len = to_read};
571 iov_iter_kvec(&smb_msg.msg_iter, READ | ITER_KVEC, &iov, 1, to_read);
572
573 return cifs_readv_from_socket(server, &smb_msg);
574}
575
576int
577cifs_read_page_from_socket(struct TCP_Server_Info *server, struct page *page,
578 unsigned int to_read)
579{
580 struct msghdr smb_msg;
581 struct bio_vec bv = {.bv_page = page, .bv_len = to_read};
582 iov_iter_bvec(&smb_msg.msg_iter, READ | ITER_BVEC, &bv, 1, to_read);
583 return cifs_readv_from_socket(server, &smb_msg);
584}
585
586static bool
587is_smb_response(struct TCP_Server_Info *server, unsigned char type)
588{
589
590
591
592
593
594 switch (type) {
595 case RFC1002_SESSION_MESSAGE:
596
597 return true;
598 case RFC1002_SESSION_KEEP_ALIVE:
599 cifs_dbg(FYI, "RFC 1002 session keep alive\n");
600 break;
601 case RFC1002_POSITIVE_SESSION_RESPONSE:
602 cifs_dbg(FYI, "RFC 1002 positive session response\n");
603 break;
604 case RFC1002_NEGATIVE_SESSION_RESPONSE:
605
606
607
608
609 cifs_dbg(FYI, "RFC 1002 negative session response\n");
610
611 msleep(1000);
612
613
614
615
616
617
618 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
619 cifs_reconnect(server);
620 wake_up(&server->response_q);
621 break;
622 default:
623 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type);
624 cifs_reconnect(server);
625 }
626
627 return false;
628}
629
630void
631dequeue_mid(struct mid_q_entry *mid, bool malformed)
632{
633#ifdef CONFIG_CIFS_STATS2
634 mid->when_received = jiffies;
635#endif
636 spin_lock(&GlobalMid_Lock);
637 if (!malformed)
638 mid->mid_state = MID_RESPONSE_RECEIVED;
639 else
640 mid->mid_state = MID_RESPONSE_MALFORMED;
641 list_del_init(&mid->qhead);
642 spin_unlock(&GlobalMid_Lock);
643}
644
645static void
646handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
647 char *buf, int malformed)
648{
649 if (server->ops->check_trans2 &&
650 server->ops->check_trans2(mid, server, buf, malformed))
651 return;
652 mid->resp_buf = buf;
653 mid->large_buf = server->large_buf;
654
655 if (!mid->multiRsp) {
656
657 if (server->large_buf)
658 server->bigbuf = NULL;
659 else
660 server->smallbuf = NULL;
661 }
662 dequeue_mid(mid, malformed);
663}
664
665static void clean_demultiplex_info(struct TCP_Server_Info *server)
666{
667 int length;
668
669
670 spin_lock(&cifs_tcp_ses_lock);
671 list_del_init(&server->tcp_ses_list);
672 spin_unlock(&cifs_tcp_ses_lock);
673
674 spin_lock(&GlobalMid_Lock);
675 server->tcpStatus = CifsExiting;
676 spin_unlock(&GlobalMid_Lock);
677 wake_up_all(&server->response_q);
678
679
680 spin_lock(&server->req_lock);
681 if (server->credits <= 0)
682 server->credits = 1;
683 spin_unlock(&server->req_lock);
684
685
686
687
688
689
690
691 wake_up_all(&server->request_q);
692
693 msleep(125);
694
695 if (server->ssocket) {
696 sock_release(server->ssocket);
697 server->ssocket = NULL;
698 }
699
700 if (!list_empty(&server->pending_mid_q)) {
701 struct list_head dispose_list;
702 struct mid_q_entry *mid_entry;
703 struct list_head *tmp, *tmp2;
704
705 INIT_LIST_HEAD(&dispose_list);
706 spin_lock(&GlobalMid_Lock);
707 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
708 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
709 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid);
710 mid_entry->mid_state = MID_SHUTDOWN;
711 list_move(&mid_entry->qhead, &dispose_list);
712 }
713 spin_unlock(&GlobalMid_Lock);
714
715
716 list_for_each_safe(tmp, tmp2, &dispose_list) {
717 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
718 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid);
719 list_del_init(&mid_entry->qhead);
720 mid_entry->callback(mid_entry);
721 }
722
723 msleep(125);
724 }
725
726 if (!list_empty(&server->pending_mid_q)) {
727
728
729
730
731
732
733
734
735 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n");
736 msleep(46000);
737
738
739
740
741 }
742
743 kfree(server->hostname);
744 kfree(server);
745
746 length = atomic_dec_return(&tcpSesAllocCount);
747 if (length > 0)
748 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
749}
750
751static int
752standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
753{
754 int length;
755 char *buf = server->smallbuf;
756 unsigned int pdu_length = get_rfc1002_length(buf);
757
758
759 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
760 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
761 cifs_reconnect(server);
762 wake_up(&server->response_q);
763 return -ECONNABORTED;
764 }
765
766
767 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
768 server->large_buf = true;
769 memcpy(server->bigbuf, buf, server->total_read);
770 buf = server->bigbuf;
771 }
772
773
774 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
775 pdu_length - HEADER_SIZE(server) + 1 + 4);
776 if (length < 0)
777 return length;
778 server->total_read += length;
779
780 dump_smb(buf, server->total_read);
781
782
783
784
785
786
787
788
789
790
791 length = server->ops->check_message(buf, server->total_read, server);
792 if (length != 0)
793 cifs_dump_mem("Bad SMB: ", buf,
794 min_t(unsigned int, server->total_read, 48));
795
796 if (server->ops->is_status_pending &&
797 server->ops->is_status_pending(buf, server, length))
798 return -1;
799
800 if (!mid)
801 return length;
802
803 handle_mid(mid, server, buf, length);
804 return 0;
805}
806
807static int
808cifs_demultiplex_thread(void *p)
809{
810 int length;
811 struct TCP_Server_Info *server = p;
812 unsigned int pdu_length;
813 char *buf = NULL;
814 struct task_struct *task_to_wake = NULL;
815 struct mid_q_entry *mid_entry;
816
817 current->flags |= PF_MEMALLOC;
818 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
819
820 length = atomic_inc_return(&tcpSesAllocCount);
821 if (length > 1)
822 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
823
824 set_freezable();
825 while (server->tcpStatus != CifsExiting) {
826 if (try_to_freeze())
827 continue;
828
829 if (!allocate_buffers(server))
830 continue;
831
832 server->large_buf = false;
833 buf = server->smallbuf;
834 pdu_length = 4;
835
836 length = cifs_read_from_socket(server, buf, pdu_length);
837 if (length < 0)
838 continue;
839 server->total_read = length;
840
841
842
843
844
845 pdu_length = get_rfc1002_length(buf);
846
847 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
848 if (!is_smb_response(server, buf[0]))
849 continue;
850
851
852 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
853 cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
854 pdu_length);
855 cifs_reconnect(server);
856 wake_up(&server->response_q);
857 continue;
858 }
859
860
861 length = cifs_read_from_socket(server, buf + 4,
862 HEADER_SIZE(server) - 1 - 4);
863 if (length < 0)
864 continue;
865 server->total_read += length;
866
867 mid_entry = server->ops->find_mid(server, buf);
868
869 if (!mid_entry || !mid_entry->receive)
870 length = standard_receive3(server, mid_entry);
871 else
872 length = mid_entry->receive(server, mid_entry);
873
874 if (length < 0)
875 continue;
876
877 if (server->large_buf)
878 buf = server->bigbuf;
879
880 server->lstrp = jiffies;
881 if (mid_entry != NULL) {
882 if (!mid_entry->multiRsp || mid_entry->multiEnd)
883 mid_entry->callback(mid_entry);
884 } else if (!server->ops->is_oplock_break ||
885 !server->ops->is_oplock_break(buf, server)) {
886 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
887 atomic_read(&midCount));
888 cifs_dump_mem("Received Data is: ", buf,
889 HEADER_SIZE(server));
890#ifdef CONFIG_CIFS_DEBUG2
891 if (server->ops->dump_detail)
892 server->ops->dump_detail(buf);
893 cifs_dump_mids(server);
894#endif
895
896 }
897 }
898
899
900 cifs_buf_release(server->bigbuf);
901 if (server->smallbuf)
902 cifs_small_buf_release(server->smallbuf);
903
904 task_to_wake = xchg(&server->tsk, NULL);
905 clean_demultiplex_info(server);
906
907
908 if (!task_to_wake) {
909 set_current_state(TASK_INTERRUPTIBLE);
910 while (!signal_pending(current)) {
911 schedule();
912 set_current_state(TASK_INTERRUPTIBLE);
913 }
914 set_current_state(TASK_RUNNING);
915 }
916
917 module_put_and_exit(0);
918}
919
920
921static char *
922extract_hostname(const char *unc)
923{
924 const char *src;
925 char *dst, *delim;
926 unsigned int len;
927
928
929
930 src = unc + 2;
931
932
933 delim = strchr(src, '\\');
934 if (!delim)
935 return ERR_PTR(-EINVAL);
936
937 len = delim - src;
938 dst = kmalloc((len + 1), GFP_KERNEL);
939 if (dst == NULL)
940 return ERR_PTR(-ENOMEM);
941
942 memcpy(dst, src, len);
943 dst[len] = '\0';
944
945 return dst;
946}
947
948static int get_option_ul(substring_t args[], unsigned long *option)
949{
950 int rc;
951 char *string;
952
953 string = match_strdup(args);
954 if (string == NULL)
955 return -ENOMEM;
956 rc = kstrtoul(string, 0, option);
957 kfree(string);
958
959 return rc;
960}
961
962static int get_option_uid(substring_t args[], kuid_t *result)
963{
964 unsigned long value;
965 kuid_t uid;
966 int rc;
967
968 rc = get_option_ul(args, &value);
969 if (rc)
970 return rc;
971
972 uid = make_kuid(current_user_ns(), value);
973 if (!uid_valid(uid))
974 return -EINVAL;
975
976 *result = uid;
977 return 0;
978}
979
980static int get_option_gid(substring_t args[], kgid_t *result)
981{
982 unsigned long value;
983 kgid_t gid;
984 int rc;
985
986 rc = get_option_ul(args, &value);
987 if (rc)
988 return rc;
989
990 gid = make_kgid(current_user_ns(), value);
991 if (!gid_valid(gid))
992 return -EINVAL;
993
994 *result = gid;
995 return 0;
996}
997
998static int cifs_parse_security_flavors(char *value,
999 struct smb_vol *vol)
1000{
1001
1002 substring_t args[MAX_OPT_ARGS];
1003
1004
1005
1006
1007
1008 vol->sectype = Unspecified;
1009 vol->sign = false;
1010
1011 switch (match_token(value, cifs_secflavor_tokens, args)) {
1012 case Opt_sec_krb5p:
1013 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1014 return 1;
1015 case Opt_sec_krb5i:
1016 vol->sign = true;
1017
1018 case Opt_sec_krb5:
1019 vol->sectype = Kerberos;
1020 break;
1021 case Opt_sec_ntlmsspi:
1022 vol->sign = true;
1023
1024 case Opt_sec_ntlmssp:
1025 vol->sectype = RawNTLMSSP;
1026 break;
1027 case Opt_sec_ntlmi:
1028 vol->sign = true;
1029
1030 case Opt_ntlm:
1031 vol->sectype = NTLM;
1032 break;
1033 case Opt_sec_ntlmv2i:
1034 vol->sign = true;
1035
1036 case Opt_sec_ntlmv2:
1037 vol->sectype = NTLMv2;
1038 break;
1039#ifdef CONFIG_CIFS_WEAK_PW_HASH
1040 case Opt_sec_lanman:
1041 vol->sectype = LANMAN;
1042 break;
1043#endif
1044 case Opt_sec_none:
1045 vol->nullauth = 1;
1046 break;
1047 default:
1048 cifs_dbg(VFS, "bad security option: %s\n", value);
1049 return 1;
1050 }
1051
1052 return 0;
1053}
1054
1055static int
1056cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1057{
1058 substring_t args[MAX_OPT_ARGS];
1059
1060 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1061 case Opt_cache_loose:
1062 vol->direct_io = false;
1063 vol->strict_io = false;
1064 break;
1065 case Opt_cache_strict:
1066 vol->direct_io = false;
1067 vol->strict_io = true;
1068 break;
1069 case Opt_cache_none:
1070 vol->direct_io = true;
1071 vol->strict_io = false;
1072 break;
1073 default:
1074 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1075 return 1;
1076 }
1077 return 0;
1078}
1079
1080static int
1081cifs_parse_smb_version(char *value, struct smb_vol *vol)
1082{
1083 substring_t args[MAX_OPT_ARGS];
1084
1085 switch (match_token(value, cifs_smb_version_tokens, args)) {
1086 case Smb_1:
1087 vol->ops = &smb1_operations;
1088 vol->vals = &smb1_values;
1089 break;
1090#ifdef CONFIG_CIFS_SMB2
1091 case Smb_20:
1092 vol->ops = &smb20_operations;
1093 vol->vals = &smb20_values;
1094 break;
1095 case Smb_21:
1096 vol->ops = &smb21_operations;
1097 vol->vals = &smb21_values;
1098 break;
1099 case Smb_30:
1100 vol->ops = &smb30_operations;
1101 vol->vals = &smb30_values;
1102 break;
1103 case Smb_302:
1104 vol->ops = &smb30_operations;
1105 vol->vals = &smb302_values;
1106 break;
1107#ifdef CONFIG_CIFS_SMB311
1108 case Smb_311:
1109 vol->ops = &smb311_operations;
1110 vol->vals = &smb311_values;
1111 break;
1112#endif
1113#endif
1114 default:
1115 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1116 return 1;
1117 }
1118 return 0;
1119}
1120
1121
1122
1123
1124
1125static int
1126cifs_parse_devname(const char *devname, struct smb_vol *vol)
1127{
1128 char *pos;
1129 const char *delims = "/\\";
1130 size_t len;
1131
1132
1133 len = strspn(devname, delims);
1134 if (len != 2)
1135 return -EINVAL;
1136
1137
1138 pos = strpbrk(devname + 2, delims);
1139 if (!pos)
1140 return -EINVAL;
1141
1142
1143 ++pos;
1144
1145
1146 len = strcspn(pos, delims);
1147
1148
1149 pos += len;
1150 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1151 if (!vol->UNC)
1152 return -ENOMEM;
1153
1154 convert_delimiter(vol->UNC, '\\');
1155
1156
1157 if (*pos == '/' || *pos == '\\')
1158 pos++;
1159
1160
1161 if (!*pos)
1162 return 0;
1163
1164 vol->prepath = kstrdup(pos, GFP_KERNEL);
1165 if (!vol->prepath)
1166 return -ENOMEM;
1167
1168 return 0;
1169}
1170
1171static int
1172cifs_parse_mount_options(const char *mountdata, const char *devname,
1173 struct smb_vol *vol)
1174{
1175 char *data, *end;
1176 char *mountdata_copy = NULL, *options;
1177 unsigned int temp_len, i, j;
1178 char separator[2];
1179 short int override_uid = -1;
1180 short int override_gid = -1;
1181 bool uid_specified = false;
1182 bool gid_specified = false;
1183 bool sloppy = false;
1184 char *invalid = NULL;
1185 char *nodename = utsname()->nodename;
1186 char *string = NULL;
1187 char *tmp_end, *value;
1188 char delim;
1189 bool got_ip = false;
1190 unsigned short port = 0;
1191 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1192
1193 separator[0] = ',';
1194 separator[1] = 0;
1195 delim = separator[0];
1196
1197
1198 memset(vol, 0, sizeof(*vol));
1199
1200
1201
1202
1203
1204
1205 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1206 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1207 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1208
1209 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1210
1211
1212 vol->target_rfc1001_name[0] = 0;
1213 vol->cred_uid = current_uid();
1214 vol->linux_uid = current_uid();
1215 vol->linux_gid = current_gid();
1216
1217
1218
1219
1220
1221
1222
1223 vol->remap = true;
1224
1225
1226 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1227
1228
1229
1230 vol->posix_paths = 1;
1231
1232 vol->server_ino = 1;
1233
1234
1235 vol->strict_io = true;
1236
1237 vol->actimeo = CIFS_DEF_ACTIMEO;
1238
1239
1240 vol->ops = &smb1_operations;
1241 vol->vals = &smb1_values;
1242
1243 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1244
1245 if (!mountdata)
1246 goto cifs_parse_mount_err;
1247
1248 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1249 if (!mountdata_copy)
1250 goto cifs_parse_mount_err;
1251
1252 options = mountdata_copy;
1253 end = options + strlen(options);
1254
1255 if (strncmp(options, "sep=", 4) == 0) {
1256 if (options[4] != 0) {
1257 separator[0] = options[4];
1258 options += 5;
1259 } else {
1260 cifs_dbg(FYI, "Null separator not allowed\n");
1261 }
1262 }
1263 vol->backupuid_specified = false;
1264 vol->backupgid_specified = false;
1265
1266 switch (cifs_parse_devname(devname, vol)) {
1267 case 0:
1268 break;
1269 case -ENOMEM:
1270 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1271 goto cifs_parse_mount_err;
1272 case -EINVAL:
1273 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1274 goto cifs_parse_mount_err;
1275 default:
1276 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1277 goto cifs_parse_mount_err;
1278 }
1279
1280 while ((data = strsep(&options, separator)) != NULL) {
1281 substring_t args[MAX_OPT_ARGS];
1282 unsigned long option;
1283 int token;
1284
1285 if (!*data)
1286 continue;
1287
1288 token = match_token(data, cifs_mount_option_tokens, args);
1289
1290 switch (token) {
1291
1292
1293 case Opt_ignore:
1294 break;
1295
1296
1297 case Opt_user_xattr:
1298 vol->no_xattr = 0;
1299 break;
1300 case Opt_nouser_xattr:
1301 vol->no_xattr = 1;
1302 break;
1303 case Opt_forceuid:
1304 override_uid = 1;
1305 break;
1306 case Opt_noforceuid:
1307 override_uid = 0;
1308 break;
1309 case Opt_forcegid:
1310 override_gid = 1;
1311 break;
1312 case Opt_noforcegid:
1313 override_gid = 0;
1314 break;
1315 case Opt_noblocksend:
1316 vol->noblocksnd = 1;
1317 break;
1318 case Opt_noautotune:
1319 vol->noautotune = 1;
1320 break;
1321 case Opt_hard:
1322 vol->retry = 1;
1323 break;
1324 case Opt_soft:
1325 vol->retry = 0;
1326 break;
1327 case Opt_perm:
1328 vol->noperm = 0;
1329 break;
1330 case Opt_noperm:
1331 vol->noperm = 1;
1332 break;
1333 case Opt_mapchars:
1334 vol->sfu_remap = true;
1335 vol->remap = false;
1336 break;
1337 case Opt_nomapchars:
1338 vol->sfu_remap = false;
1339 break;
1340 case Opt_mapposix:
1341 vol->remap = true;
1342 vol->sfu_remap = false;
1343 break;
1344 case Opt_nomapposix:
1345 vol->remap = false;
1346 break;
1347 case Opt_sfu:
1348 vol->sfu_emul = 1;
1349 break;
1350 case Opt_nosfu:
1351 vol->sfu_emul = 0;
1352 break;
1353 case Opt_nodfs:
1354 vol->nodfs = 1;
1355 break;
1356 case Opt_posixpaths:
1357 vol->posix_paths = 1;
1358 break;
1359 case Opt_noposixpaths:
1360 vol->posix_paths = 0;
1361 break;
1362 case Opt_nounix:
1363 vol->no_linux_ext = 1;
1364 break;
1365 case Opt_nocase:
1366 vol->nocase = 1;
1367 break;
1368 case Opt_brl:
1369 vol->nobrl = 0;
1370 break;
1371 case Opt_nobrl:
1372 vol->nobrl = 1;
1373
1374
1375
1376
1377
1378 if (vol->file_mode ==
1379 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1380 vol->file_mode = S_IALLUGO;
1381 break;
1382 case Opt_forcemandatorylock:
1383 vol->mand_lock = 1;
1384 break;
1385 case Opt_setuids:
1386 vol->setuids = 1;
1387 break;
1388 case Opt_nosetuids:
1389 vol->setuids = 0;
1390 break;
1391 case Opt_setuidfromacl:
1392 vol->setuidfromacl = 1;
1393 break;
1394 case Opt_dynperm:
1395 vol->dynperm = true;
1396 break;
1397 case Opt_nodynperm:
1398 vol->dynperm = false;
1399 break;
1400 case Opt_nohard:
1401 vol->retry = 0;
1402 break;
1403 case Opt_nosoft:
1404 vol->retry = 1;
1405 break;
1406 case Opt_nointr:
1407 vol->intr = 0;
1408 break;
1409 case Opt_intr:
1410 vol->intr = 1;
1411 break;
1412 case Opt_nostrictsync:
1413 vol->nostrictsync = 1;
1414 break;
1415 case Opt_strictsync:
1416 vol->nostrictsync = 0;
1417 break;
1418 case Opt_serverino:
1419 vol->server_ino = 1;
1420 break;
1421 case Opt_noserverino:
1422 vol->server_ino = 0;
1423 break;
1424 case Opt_rwpidforward:
1425 vol->rwpidforward = 1;
1426 break;
1427 case Opt_cifsacl:
1428 vol->cifs_acl = 1;
1429 break;
1430 case Opt_nocifsacl:
1431 vol->cifs_acl = 0;
1432 break;
1433 case Opt_acl:
1434 vol->no_psx_acl = 0;
1435 break;
1436 case Opt_noacl:
1437 vol->no_psx_acl = 1;
1438 break;
1439 case Opt_locallease:
1440 vol->local_lease = 1;
1441 break;
1442 case Opt_sign:
1443 vol->sign = true;
1444 break;
1445 case Opt_seal:
1446
1447
1448
1449
1450
1451 vol->seal = 1;
1452 break;
1453 case Opt_noac:
1454 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1455 break;
1456 case Opt_fsc:
1457#ifndef CONFIG_CIFS_FSCACHE
1458 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1459 goto cifs_parse_mount_err;
1460#endif
1461 vol->fsc = true;
1462 break;
1463 case Opt_mfsymlinks:
1464 vol->mfsymlinks = true;
1465 break;
1466 case Opt_multiuser:
1467 vol->multiuser = true;
1468 break;
1469 case Opt_sloppy:
1470 sloppy = true;
1471 break;
1472 case Opt_nosharesock:
1473 vol->nosharesock = true;
1474 break;
1475 case Opt_nopersistent:
1476 vol->nopersistent = true;
1477 if (vol->persistent) {
1478 cifs_dbg(VFS,
1479 "persistenthandles mount options conflict\n");
1480 goto cifs_parse_mount_err;
1481 }
1482 break;
1483 case Opt_persistent:
1484 vol->persistent = true;
1485 if ((vol->nopersistent) || (vol->resilient)) {
1486 cifs_dbg(VFS,
1487 "persistenthandles mount options conflict\n");
1488 goto cifs_parse_mount_err;
1489 }
1490 break;
1491 case Opt_resilient:
1492 vol->resilient = true;
1493 if (vol->persistent) {
1494 cifs_dbg(VFS,
1495 "persistenthandles mount options conflict\n");
1496 goto cifs_parse_mount_err;
1497 }
1498 break;
1499 case Opt_noresilient:
1500 vol->resilient = false;
1501 break;
1502
1503
1504 case Opt_backupuid:
1505 if (get_option_uid(args, &vol->backupuid)) {
1506 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1507 __func__);
1508 goto cifs_parse_mount_err;
1509 }
1510 vol->backupuid_specified = true;
1511 break;
1512 case Opt_backupgid:
1513 if (get_option_gid(args, &vol->backupgid)) {
1514 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1515 __func__);
1516 goto cifs_parse_mount_err;
1517 }
1518 vol->backupgid_specified = true;
1519 break;
1520 case Opt_uid:
1521 if (get_option_uid(args, &vol->linux_uid)) {
1522 cifs_dbg(VFS, "%s: Invalid uid value\n",
1523 __func__);
1524 goto cifs_parse_mount_err;
1525 }
1526 uid_specified = true;
1527 break;
1528 case Opt_cruid:
1529 if (get_option_uid(args, &vol->cred_uid)) {
1530 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1531 __func__);
1532 goto cifs_parse_mount_err;
1533 }
1534 break;
1535 case Opt_gid:
1536 if (get_option_gid(args, &vol->linux_gid)) {
1537 cifs_dbg(VFS, "%s: Invalid gid value\n",
1538 __func__);
1539 goto cifs_parse_mount_err;
1540 }
1541 gid_specified = true;
1542 break;
1543 case Opt_file_mode:
1544 if (get_option_ul(args, &option)) {
1545 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1546 __func__);
1547 goto cifs_parse_mount_err;
1548 }
1549 vol->file_mode = option;
1550 break;
1551 case Opt_dirmode:
1552 if (get_option_ul(args, &option)) {
1553 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1554 __func__);
1555 goto cifs_parse_mount_err;
1556 }
1557 vol->dir_mode = option;
1558 break;
1559 case Opt_port:
1560 if (get_option_ul(args, &option) ||
1561 option > USHRT_MAX) {
1562 cifs_dbg(VFS, "%s: Invalid port value\n",
1563 __func__);
1564 goto cifs_parse_mount_err;
1565 }
1566 port = (unsigned short)option;
1567 break;
1568 case Opt_rsize:
1569 if (get_option_ul(args, &option)) {
1570 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1571 __func__);
1572 goto cifs_parse_mount_err;
1573 }
1574 vol->rsize = option;
1575 break;
1576 case Opt_wsize:
1577 if (get_option_ul(args, &option)) {
1578 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1579 __func__);
1580 goto cifs_parse_mount_err;
1581 }
1582 vol->wsize = option;
1583 break;
1584 case Opt_actimeo:
1585 if (get_option_ul(args, &option)) {
1586 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1587 __func__);
1588 goto cifs_parse_mount_err;
1589 }
1590 vol->actimeo = HZ * option;
1591 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1592 cifs_dbg(VFS, "attribute cache timeout too large\n");
1593 goto cifs_parse_mount_err;
1594 }
1595 break;
1596 case Opt_echo_interval:
1597 if (get_option_ul(args, &option)) {
1598 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1599 __func__);
1600 goto cifs_parse_mount_err;
1601 }
1602 vol->echo_interval = option;
1603 break;
1604 case Opt_max_credits:
1605 if (get_option_ul(args, &option) || (option < 20) ||
1606 (option > 60000)) {
1607 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1608 __func__);
1609 goto cifs_parse_mount_err;
1610 }
1611 vol->max_credits = option;
1612 break;
1613
1614
1615
1616 case Opt_blank_user:
1617
1618 vol->nullauth = 1;
1619 vol->username = NULL;
1620 break;
1621 case Opt_user:
1622 string = match_strdup(args);
1623 if (string == NULL)
1624 goto out_nomem;
1625
1626 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1627 CIFS_MAX_USERNAME_LEN) {
1628 pr_warn("CIFS: username too long\n");
1629 goto cifs_parse_mount_err;
1630 }
1631
1632 kfree(vol->username);
1633 vol->username = kstrdup(string, GFP_KERNEL);
1634 if (!vol->username)
1635 goto cifs_parse_mount_err;
1636 break;
1637 case Opt_blank_pass:
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647 tmp_end = strchr(data, '=');
1648 tmp_end++;
1649 if (!(tmp_end < end && tmp_end[1] == delim)) {
1650
1651 kfree(vol->password);
1652 vol->password = NULL;
1653 break;
1654 }
1655
1656 case Opt_pass:
1657
1658 value = strchr(data, '=');
1659 value++;
1660
1661
1662 tmp_end = (char *) value + strlen(value);
1663
1664
1665
1666
1667
1668 if (tmp_end < end && tmp_end[1] == delim) {
1669 tmp_end[0] = delim;
1670
1671
1672
1673
1674 while ((tmp_end = strchr(tmp_end, delim))
1675 != NULL && (tmp_end[1] == delim)) {
1676 tmp_end = (char *) &tmp_end[2];
1677 }
1678
1679
1680 if (tmp_end) {
1681 tmp_end[0] = '\0';
1682 options = (char *) &tmp_end[1];
1683 } else
1684
1685
1686 options = end;
1687 }
1688
1689 kfree(vol->password);
1690
1691 temp_len = strlen(value);
1692 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1693 if (vol->password == NULL) {
1694 pr_warn("CIFS: no memory for password\n");
1695 goto cifs_parse_mount_err;
1696 }
1697
1698 for (i = 0, j = 0; i < temp_len; i++, j++) {
1699 vol->password[j] = value[i];
1700 if ((value[i] == delim) &&
1701 value[i+1] == delim)
1702
1703 i++;
1704 }
1705 vol->password[j] = '\0';
1706 break;
1707 case Opt_blank_ip:
1708
1709 got_ip = false;
1710 break;
1711 case Opt_ip:
1712 string = match_strdup(args);
1713 if (string == NULL)
1714 goto out_nomem;
1715
1716 if (!cifs_convert_address(dstaddr, string,
1717 strlen(string))) {
1718 pr_err("CIFS: bad ip= option (%s).\n", string);
1719 goto cifs_parse_mount_err;
1720 }
1721 got_ip = true;
1722 break;
1723 case Opt_domain:
1724 string = match_strdup(args);
1725 if (string == NULL)
1726 goto out_nomem;
1727
1728 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1729 == CIFS_MAX_DOMAINNAME_LEN) {
1730 pr_warn("CIFS: domain name too long\n");
1731 goto cifs_parse_mount_err;
1732 }
1733
1734 kfree(vol->domainname);
1735 vol->domainname = kstrdup(string, GFP_KERNEL);
1736 if (!vol->domainname) {
1737 pr_warn("CIFS: no memory for domainname\n");
1738 goto cifs_parse_mount_err;
1739 }
1740 cifs_dbg(FYI, "Domain name set\n");
1741 break;
1742 case Opt_srcaddr:
1743 string = match_strdup(args);
1744 if (string == NULL)
1745 goto out_nomem;
1746
1747 if (!cifs_convert_address(
1748 (struct sockaddr *)&vol->srcaddr,
1749 string, strlen(string))) {
1750 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1751 string);
1752 goto cifs_parse_mount_err;
1753 }
1754 break;
1755 case Opt_iocharset:
1756 string = match_strdup(args);
1757 if (string == NULL)
1758 goto out_nomem;
1759
1760 if (strnlen(string, 1024) >= 65) {
1761 pr_warn("CIFS: iocharset name too long.\n");
1762 goto cifs_parse_mount_err;
1763 }
1764
1765 if (strncasecmp(string, "default", 7) != 0) {
1766 kfree(vol->iocharset);
1767 vol->iocharset = kstrdup(string,
1768 GFP_KERNEL);
1769 if (!vol->iocharset) {
1770 pr_warn("CIFS: no memory for charset\n");
1771 goto cifs_parse_mount_err;
1772 }
1773 }
1774
1775
1776
1777 cifs_dbg(FYI, "iocharset set to %s\n", string);
1778 break;
1779 case Opt_netbiosname:
1780 string = match_strdup(args);
1781 if (string == NULL)
1782 goto out_nomem;
1783
1784 memset(vol->source_rfc1001_name, 0x20,
1785 RFC1001_NAME_LEN);
1786
1787
1788
1789
1790
1791 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1792
1793 if (string[i] == 0)
1794 break;
1795 vol->source_rfc1001_name[i] = string[i];
1796 }
1797
1798
1799
1800 if (i == RFC1001_NAME_LEN && string[i] != 0)
1801 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1802 break;
1803 case Opt_servern:
1804
1805 string = match_strdup(args);
1806 if (string == NULL)
1807 goto out_nomem;
1808
1809
1810 memset(vol->target_rfc1001_name, 0x20,
1811 RFC1001_NAME_LEN_WITH_NULL);
1812
1813
1814
1815
1816
1817
1818
1819 for (i = 0; i < 15; i++) {
1820 if (string[i] == 0)
1821 break;
1822 vol->target_rfc1001_name[i] = string[i];
1823 }
1824
1825
1826 if (i == RFC1001_NAME_LEN && string[i] != 0)
1827 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1828 break;
1829 case Opt_ver:
1830 string = match_strdup(args);
1831 if (string == NULL)
1832 goto out_nomem;
1833
1834 if (strncasecmp(string, "1", 1) == 0) {
1835
1836 break;
1837 }
1838
1839 pr_warn("CIFS: Invalid version specified\n");
1840 goto cifs_parse_mount_err;
1841 case Opt_vers:
1842 string = match_strdup(args);
1843 if (string == NULL)
1844 goto out_nomem;
1845
1846 if (cifs_parse_smb_version(string, vol) != 0)
1847 goto cifs_parse_mount_err;
1848 break;
1849 case Opt_sec:
1850 string = match_strdup(args);
1851 if (string == NULL)
1852 goto out_nomem;
1853
1854 if (cifs_parse_security_flavors(string, vol) != 0)
1855 goto cifs_parse_mount_err;
1856 break;
1857 case Opt_cache:
1858 string = match_strdup(args);
1859 if (string == NULL)
1860 goto out_nomem;
1861
1862 if (cifs_parse_cache_flavor(string, vol) != 0)
1863 goto cifs_parse_mount_err;
1864 break;
1865 default:
1866
1867
1868
1869
1870 if (!invalid)
1871 invalid = data;
1872 break;
1873 }
1874
1875 kfree(string);
1876 string = NULL;
1877 }
1878
1879 if (!sloppy && invalid) {
1880 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1881 goto cifs_parse_mount_err;
1882 }
1883
1884#ifndef CONFIG_KEYS
1885
1886 if (vol->multiuser) {
1887 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1888 goto cifs_parse_mount_err;
1889 }
1890#endif
1891 if (!vol->UNC) {
1892 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1893 goto cifs_parse_mount_err;
1894 }
1895
1896
1897 if (!strchr(vol->UNC + 3, '\\')) {
1898 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1899 goto cifs_parse_mount_err;
1900 }
1901
1902 if (!got_ip) {
1903
1904 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1905 strlen(&vol->UNC[2]))) {
1906 pr_err("Unable to determine destination address.\n");
1907 goto cifs_parse_mount_err;
1908 }
1909 }
1910
1911
1912 cifs_set_port(dstaddr, port);
1913
1914 if (uid_specified)
1915 vol->override_uid = override_uid;
1916 else if (override_uid == 1)
1917 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1918
1919 if (gid_specified)
1920 vol->override_gid = override_gid;
1921 else if (override_gid == 1)
1922 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1923
1924 kfree(mountdata_copy);
1925 return 0;
1926
1927out_nomem:
1928 pr_warn("Could not allocate temporary buffer\n");
1929cifs_parse_mount_err:
1930 kfree(string);
1931 kfree(mountdata_copy);
1932 return 1;
1933}
1934
1935
1936
1937
1938
1939static bool
1940srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1941{
1942 switch (srcaddr->sa_family) {
1943 case AF_UNSPEC:
1944 return (rhs->sa_family == AF_UNSPEC);
1945 case AF_INET: {
1946 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1947 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1948 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1949 }
1950 case AF_INET6: {
1951 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1952 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1953 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1954 }
1955 default:
1956 WARN_ON(1);
1957 return false;
1958 }
1959}
1960
1961
1962
1963
1964
1965
1966static bool
1967match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1968{
1969 __be16 port, *sport;
1970
1971 switch (addr->sa_family) {
1972 case AF_INET:
1973 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1974 port = ((struct sockaddr_in *) addr)->sin_port;
1975 break;
1976 case AF_INET6:
1977 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1978 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1979 break;
1980 default:
1981 WARN_ON(1);
1982 return false;
1983 }
1984
1985 if (!port) {
1986 port = htons(CIFS_PORT);
1987 if (port == *sport)
1988 return true;
1989
1990 port = htons(RFC1001_PORT);
1991 }
1992
1993 return port == *sport;
1994}
1995
1996static bool
1997match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1998 struct sockaddr *srcaddr)
1999{
2000 switch (addr->sa_family) {
2001 case AF_INET: {
2002 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2003 struct sockaddr_in *srv_addr4 =
2004 (struct sockaddr_in *)&server->dstaddr;
2005
2006 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2007 return false;
2008 break;
2009 }
2010 case AF_INET6: {
2011 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2012 struct sockaddr_in6 *srv_addr6 =
2013 (struct sockaddr_in6 *)&server->dstaddr;
2014
2015 if (!ipv6_addr_equal(&addr6->sin6_addr,
2016 &srv_addr6->sin6_addr))
2017 return false;
2018 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2019 return false;
2020 break;
2021 }
2022 default:
2023 WARN_ON(1);
2024 return false;
2025 }
2026
2027 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2028 return false;
2029
2030 return true;
2031}
2032
2033static bool
2034match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2035{
2036
2037
2038
2039
2040
2041 if (select_sectype(server, vol->sectype) == Unspecified)
2042 return false;
2043
2044
2045
2046
2047
2048
2049 if (vol->sign && !server->sign)
2050 return false;
2051
2052 return true;
2053}
2054
2055static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2056{
2057 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2058
2059 if (vol->nosharesock)
2060 return 0;
2061
2062 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2063 return 0;
2064
2065 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2066 return 0;
2067
2068 if (!match_address(server, addr,
2069 (struct sockaddr *)&vol->srcaddr))
2070 return 0;
2071
2072 if (!match_port(server, addr))
2073 return 0;
2074
2075 if (!match_security(server, vol))
2076 return 0;
2077
2078 if (server->echo_interval != vol->echo_interval * HZ)
2079 return 0;
2080
2081 return 1;
2082}
2083
2084static struct TCP_Server_Info *
2085cifs_find_tcp_session(struct smb_vol *vol)
2086{
2087 struct TCP_Server_Info *server;
2088
2089 spin_lock(&cifs_tcp_ses_lock);
2090 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2091 if (!match_server(server, vol))
2092 continue;
2093
2094 ++server->srv_count;
2095 spin_unlock(&cifs_tcp_ses_lock);
2096 cifs_dbg(FYI, "Existing tcp session with server found\n");
2097 return server;
2098 }
2099 spin_unlock(&cifs_tcp_ses_lock);
2100 return NULL;
2101}
2102
2103static void
2104cifs_put_tcp_session(struct TCP_Server_Info *server)
2105{
2106 struct task_struct *task;
2107
2108 spin_lock(&cifs_tcp_ses_lock);
2109 if (--server->srv_count > 0) {
2110 spin_unlock(&cifs_tcp_ses_lock);
2111 return;
2112 }
2113
2114 put_net(cifs_net_ns(server));
2115
2116 list_del_init(&server->tcp_ses_list);
2117 spin_unlock(&cifs_tcp_ses_lock);
2118
2119 cancel_delayed_work_sync(&server->echo);
2120
2121 spin_lock(&GlobalMid_Lock);
2122 server->tcpStatus = CifsExiting;
2123 spin_unlock(&GlobalMid_Lock);
2124
2125 cifs_crypto_shash_release(server);
2126 cifs_fscache_release_client_cookie(server);
2127
2128 kfree(server->session_key.response);
2129 server->session_key.response = NULL;
2130 server->session_key.len = 0;
2131
2132 task = xchg(&server->tsk, NULL);
2133 if (task)
2134 force_sig(SIGKILL, task);
2135}
2136
2137static struct TCP_Server_Info *
2138cifs_get_tcp_session(struct smb_vol *volume_info)
2139{
2140 struct TCP_Server_Info *tcp_ses = NULL;
2141 int rc;
2142
2143 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2144
2145
2146 tcp_ses = cifs_find_tcp_session(volume_info);
2147 if (tcp_ses)
2148 return tcp_ses;
2149
2150 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2151 if (!tcp_ses) {
2152 rc = -ENOMEM;
2153 goto out_err;
2154 }
2155
2156 tcp_ses->ops = volume_info->ops;
2157 tcp_ses->vals = volume_info->vals;
2158 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2159 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2160 if (IS_ERR(tcp_ses->hostname)) {
2161 rc = PTR_ERR(tcp_ses->hostname);
2162 goto out_err_crypto_release;
2163 }
2164
2165 tcp_ses->noblocksnd = volume_info->noblocksnd;
2166 tcp_ses->noautotune = volume_info->noautotune;
2167 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2168 tcp_ses->in_flight = 0;
2169 tcp_ses->credits = 1;
2170 init_waitqueue_head(&tcp_ses->response_q);
2171 init_waitqueue_head(&tcp_ses->request_q);
2172 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2173 mutex_init(&tcp_ses->srv_mutex);
2174 memcpy(tcp_ses->workstation_RFC1001_name,
2175 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2176 memcpy(tcp_ses->server_RFC1001_name,
2177 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2178 tcp_ses->session_estab = false;
2179 tcp_ses->sequence_number = 0;
2180 tcp_ses->lstrp = jiffies;
2181 spin_lock_init(&tcp_ses->req_lock);
2182 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2183 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2184 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2185 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2186 sizeof(tcp_ses->srcaddr));
2187 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2188 sizeof(tcp_ses->dstaddr));
2189#ifdef CONFIG_CIFS_SMB2
2190 generate_random_uuid(tcp_ses->client_guid);
2191#endif
2192
2193
2194
2195
2196
2197 tcp_ses->tcpStatus = CifsNew;
2198 ++tcp_ses->srv_count;
2199
2200 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2201 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2202 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2203 else
2204 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2205
2206 rc = ip_connect(tcp_ses);
2207 if (rc < 0) {
2208 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2209 goto out_err_crypto_release;
2210 }
2211
2212
2213
2214
2215
2216 __module_get(THIS_MODULE);
2217 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2218 tcp_ses, "cifsd");
2219 if (IS_ERR(tcp_ses->tsk)) {
2220 rc = PTR_ERR(tcp_ses->tsk);
2221 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2222 module_put(THIS_MODULE);
2223 goto out_err_crypto_release;
2224 }
2225 tcp_ses->tcpStatus = CifsNeedNegotiate;
2226
2227
2228 spin_lock(&cifs_tcp_ses_lock);
2229 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2230 spin_unlock(&cifs_tcp_ses_lock);
2231
2232 cifs_fscache_get_client_cookie(tcp_ses);
2233
2234
2235 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2236
2237 return tcp_ses;
2238
2239out_err_crypto_release:
2240 cifs_crypto_shash_release(tcp_ses);
2241
2242 put_net(cifs_net_ns(tcp_ses));
2243
2244out_err:
2245 if (tcp_ses) {
2246 if (!IS_ERR(tcp_ses->hostname))
2247 kfree(tcp_ses->hostname);
2248 if (tcp_ses->ssocket)
2249 sock_release(tcp_ses->ssocket);
2250 kfree(tcp_ses);
2251 }
2252 return ERR_PTR(rc);
2253}
2254
2255static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2256{
2257 if (vol->sectype != Unspecified &&
2258 vol->sectype != ses->sectype)
2259 return 0;
2260
2261 switch (ses->sectype) {
2262 case Kerberos:
2263 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2264 return 0;
2265 break;
2266 default:
2267
2268 if (ses->user_name == NULL) {
2269 if (!vol->nullauth)
2270 return 0;
2271 break;
2272 }
2273
2274
2275 if (strncmp(ses->user_name,
2276 vol->username ? vol->username : "",
2277 CIFS_MAX_USERNAME_LEN))
2278 return 0;
2279 if ((vol->username && strlen(vol->username) != 0) &&
2280 ses->password != NULL &&
2281 strncmp(ses->password,
2282 vol->password ? vol->password : "",
2283 CIFS_MAX_PASSWORD_LEN))
2284 return 0;
2285 }
2286 return 1;
2287}
2288
2289static struct cifs_ses *
2290cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2291{
2292 struct cifs_ses *ses;
2293
2294 spin_lock(&cifs_tcp_ses_lock);
2295 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2296 if (ses->status == CifsExiting)
2297 continue;
2298 if (!match_session(ses, vol))
2299 continue;
2300 ++ses->ses_count;
2301 spin_unlock(&cifs_tcp_ses_lock);
2302 return ses;
2303 }
2304 spin_unlock(&cifs_tcp_ses_lock);
2305 return NULL;
2306}
2307
2308static void
2309cifs_put_smb_ses(struct cifs_ses *ses)
2310{
2311 unsigned int rc, xid;
2312 struct TCP_Server_Info *server = ses->server;
2313
2314 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2315
2316 spin_lock(&cifs_tcp_ses_lock);
2317 if (ses->status == CifsExiting) {
2318 spin_unlock(&cifs_tcp_ses_lock);
2319 return;
2320 }
2321 if (--ses->ses_count > 0) {
2322 spin_unlock(&cifs_tcp_ses_lock);
2323 return;
2324 }
2325 if (ses->status == CifsGood)
2326 ses->status = CifsExiting;
2327 spin_unlock(&cifs_tcp_ses_lock);
2328
2329 if (ses->status == CifsExiting && server->ops->logoff) {
2330 xid = get_xid();
2331 rc = server->ops->logoff(xid, ses);
2332 if (rc)
2333 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2334 __func__, rc);
2335 _free_xid(xid);
2336 }
2337
2338 spin_lock(&cifs_tcp_ses_lock);
2339 list_del_init(&ses->smb_ses_list);
2340 spin_unlock(&cifs_tcp_ses_lock);
2341
2342 sesInfoFree(ses);
2343 cifs_put_tcp_session(server);
2344}
2345
2346#ifdef CONFIG_KEYS
2347
2348
2349#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2350
2351
2352static int
2353cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2354{
2355 int rc = 0;
2356 const char *delim, *payload;
2357 char *desc;
2358 ssize_t len;
2359 struct key *key;
2360 struct TCP_Server_Info *server = ses->server;
2361 struct sockaddr_in *sa;
2362 struct sockaddr_in6 *sa6;
2363 const struct user_key_payload *upayload;
2364
2365 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2366 if (!desc)
2367 return -ENOMEM;
2368
2369
2370 switch (server->dstaddr.ss_family) {
2371 case AF_INET:
2372 sa = (struct sockaddr_in *)&server->dstaddr;
2373 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2374 break;
2375 case AF_INET6:
2376 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2377 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2378 break;
2379 default:
2380 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2381 server->dstaddr.ss_family);
2382 rc = -EINVAL;
2383 goto out_err;
2384 }
2385
2386 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2387 key = request_key(&key_type_logon, desc, "");
2388 if (IS_ERR(key)) {
2389 if (!ses->domainName) {
2390 cifs_dbg(FYI, "domainName is NULL\n");
2391 rc = PTR_ERR(key);
2392 goto out_err;
2393 }
2394
2395
2396 sprintf(desc, "cifs:d:%s", ses->domainName);
2397 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2398 key = request_key(&key_type_logon, desc, "");
2399 if (IS_ERR(key)) {
2400 rc = PTR_ERR(key);
2401 goto out_err;
2402 }
2403 }
2404
2405 down_read(&key->sem);
2406 upayload = user_key_payload(key);
2407 if (IS_ERR_OR_NULL(upayload)) {
2408 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2409 goto out_key_put;
2410 }
2411
2412
2413 payload = upayload->data;
2414 delim = strnchr(payload, upayload->datalen, ':');
2415 cifs_dbg(FYI, "payload=%s\n", payload);
2416 if (!delim) {
2417 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2418 upayload->datalen);
2419 rc = -EINVAL;
2420 goto out_key_put;
2421 }
2422
2423 len = delim - payload;
2424 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2425 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2426 len);
2427 rc = -EINVAL;
2428 goto out_key_put;
2429 }
2430
2431 vol->username = kstrndup(payload, len, GFP_KERNEL);
2432 if (!vol->username) {
2433 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2434 len);
2435 rc = -ENOMEM;
2436 goto out_key_put;
2437 }
2438 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2439
2440 len = key->datalen - (len + 1);
2441 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2442 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2443 rc = -EINVAL;
2444 kfree(vol->username);
2445 vol->username = NULL;
2446 goto out_key_put;
2447 }
2448
2449 ++delim;
2450 vol->password = kstrndup(delim, len, GFP_KERNEL);
2451 if (!vol->password) {
2452 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2453 len);
2454 rc = -ENOMEM;
2455 kfree(vol->username);
2456 vol->username = NULL;
2457 goto out_key_put;
2458 }
2459
2460out_key_put:
2461 up_read(&key->sem);
2462 key_put(key);
2463out_err:
2464 kfree(desc);
2465 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2466 return rc;
2467}
2468#else
2469static inline int
2470cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2471 struct cifs_ses *ses __attribute__((unused)))
2472{
2473 return -ENOSYS;
2474}
2475#endif
2476
2477static struct cifs_ses *
2478cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2479{
2480 int rc = -ENOMEM;
2481 unsigned int xid;
2482 struct cifs_ses *ses;
2483 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2484 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2485
2486 xid = get_xid();
2487
2488 ses = cifs_find_smb_ses(server, volume_info);
2489 if (ses) {
2490 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2491 ses->status);
2492
2493 mutex_lock(&ses->session_mutex);
2494 rc = cifs_negotiate_protocol(xid, ses);
2495 if (rc) {
2496 mutex_unlock(&ses->session_mutex);
2497
2498 cifs_put_smb_ses(ses);
2499 free_xid(xid);
2500 return ERR_PTR(rc);
2501 }
2502 if (ses->need_reconnect) {
2503 cifs_dbg(FYI, "Session needs reconnect\n");
2504 rc = cifs_setup_session(xid, ses,
2505 volume_info->local_nls);
2506 if (rc) {
2507 mutex_unlock(&ses->session_mutex);
2508
2509 cifs_put_smb_ses(ses);
2510 free_xid(xid);
2511 return ERR_PTR(rc);
2512 }
2513 }
2514 mutex_unlock(&ses->session_mutex);
2515
2516
2517 cifs_put_tcp_session(server);
2518 free_xid(xid);
2519 return ses;
2520 }
2521
2522 cifs_dbg(FYI, "Existing smb sess not found\n");
2523 ses = sesInfoAlloc();
2524 if (ses == NULL)
2525 goto get_ses_fail;
2526
2527
2528 ses->server = server;
2529 if (server->dstaddr.ss_family == AF_INET6)
2530 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2531 else
2532 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2533
2534 if (volume_info->username) {
2535 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2536 if (!ses->user_name)
2537 goto get_ses_fail;
2538 }
2539
2540
2541 if (volume_info->password) {
2542 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2543 if (!ses->password)
2544 goto get_ses_fail;
2545 }
2546 if (volume_info->domainname) {
2547 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2548 if (!ses->domainName)
2549 goto get_ses_fail;
2550 }
2551 ses->cred_uid = volume_info->cred_uid;
2552 ses->linux_uid = volume_info->linux_uid;
2553
2554 ses->sectype = volume_info->sectype;
2555 ses->sign = volume_info->sign;
2556
2557 mutex_lock(&ses->session_mutex);
2558 rc = cifs_negotiate_protocol(xid, ses);
2559 if (!rc)
2560 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2561 mutex_unlock(&ses->session_mutex);
2562 if (rc)
2563 goto get_ses_fail;
2564
2565
2566 spin_lock(&cifs_tcp_ses_lock);
2567 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2568 spin_unlock(&cifs_tcp_ses_lock);
2569
2570 free_xid(xid);
2571 return ses;
2572
2573get_ses_fail:
2574 sesInfoFree(ses);
2575 free_xid(xid);
2576 return ERR_PTR(rc);
2577}
2578
2579static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2580{
2581 if (tcon->tidStatus == CifsExiting)
2582 return 0;
2583 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2584 return 0;
2585 return 1;
2586}
2587
2588static struct cifs_tcon *
2589cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2590{
2591 struct list_head *tmp;
2592 struct cifs_tcon *tcon;
2593
2594 spin_lock(&cifs_tcp_ses_lock);
2595 list_for_each(tmp, &ses->tcon_list) {
2596 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2597 if (!match_tcon(tcon, unc))
2598 continue;
2599 ++tcon->tc_count;
2600 spin_unlock(&cifs_tcp_ses_lock);
2601 return tcon;
2602 }
2603 spin_unlock(&cifs_tcp_ses_lock);
2604 return NULL;
2605}
2606
2607static void
2608cifs_put_tcon(struct cifs_tcon *tcon)
2609{
2610 unsigned int xid;
2611 struct cifs_ses *ses = tcon->ses;
2612
2613 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2614 spin_lock(&cifs_tcp_ses_lock);
2615 if (--tcon->tc_count > 0) {
2616 spin_unlock(&cifs_tcp_ses_lock);
2617 return;
2618 }
2619
2620 list_del_init(&tcon->tcon_list);
2621 spin_unlock(&cifs_tcp_ses_lock);
2622
2623 xid = get_xid();
2624 if (ses->server->ops->tree_disconnect)
2625 ses->server->ops->tree_disconnect(xid, tcon);
2626 _free_xid(xid);
2627
2628 cifs_fscache_release_super_cookie(tcon);
2629 tconInfoFree(tcon);
2630 cifs_put_smb_ses(ses);
2631}
2632
2633static struct cifs_tcon *
2634cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2635{
2636 int rc, xid;
2637 struct cifs_tcon *tcon;
2638
2639 tcon = cifs_find_tcon(ses, volume_info->UNC);
2640 if (tcon) {
2641 cifs_dbg(FYI, "Found match on UNC path\n");
2642
2643 cifs_put_smb_ses(ses);
2644 if (tcon->seal != volume_info->seal)
2645 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2646 return tcon;
2647 }
2648
2649 if (!ses->server->ops->tree_connect) {
2650 rc = -ENOSYS;
2651 goto out_fail;
2652 }
2653
2654 tcon = tconInfoAlloc();
2655 if (tcon == NULL) {
2656 rc = -ENOMEM;
2657 goto out_fail;
2658 }
2659
2660 tcon->ses = ses;
2661 if (volume_info->password) {
2662 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2663 if (!tcon->password) {
2664 rc = -ENOMEM;
2665 goto out_fail;
2666 }
2667 }
2668
2669
2670
2671
2672
2673 xid = get_xid();
2674 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2675 volume_info->local_nls);
2676 free_xid(xid);
2677 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2678 if (rc)
2679 goto out_fail;
2680
2681 if (volume_info->nodfs) {
2682 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2683 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2684 }
2685 tcon->seal = volume_info->seal;
2686 tcon->use_persistent = false;
2687
2688 if (volume_info->persistent) {
2689 if (ses->server->vals->protocol_id == 0) {
2690 cifs_dbg(VFS,
2691 "SMB3 or later required for persistent handles\n");
2692 rc = -EOPNOTSUPP;
2693 goto out_fail;
2694#ifdef CONFIG_CIFS_SMB2
2695 } else if (ses->server->capabilities &
2696 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2697 tcon->use_persistent = true;
2698 else {
2699 cifs_dbg(VFS,
2700 "Persistent handles not supported on share\n");
2701 rc = -EOPNOTSUPP;
2702 goto out_fail;
2703#endif
2704 }
2705#ifdef CONFIG_CIFS_SMB2
2706 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2707 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2708 && (volume_info->nopersistent == false)) {
2709 cifs_dbg(FYI, "enabling persistent handles\n");
2710 tcon->use_persistent = true;
2711#endif
2712 } else if (volume_info->resilient) {
2713 if (ses->server->vals->protocol_id == 0) {
2714 cifs_dbg(VFS,
2715 "SMB2.1 or later required for resilient handles\n");
2716 rc = -EOPNOTSUPP;
2717 goto out_fail;
2718 }
2719 tcon->use_resilient = true;
2720 }
2721
2722
2723
2724
2725
2726
2727 tcon->retry = volume_info->retry;
2728 tcon->nocase = volume_info->nocase;
2729 tcon->local_lease = volume_info->local_lease;
2730 INIT_LIST_HEAD(&tcon->pending_opens);
2731
2732 spin_lock(&cifs_tcp_ses_lock);
2733 list_add(&tcon->tcon_list, &ses->tcon_list);
2734 spin_unlock(&cifs_tcp_ses_lock);
2735
2736 cifs_fscache_get_super_cookie(tcon);
2737
2738 return tcon;
2739
2740out_fail:
2741 tconInfoFree(tcon);
2742 return ERR_PTR(rc);
2743}
2744
2745void
2746cifs_put_tlink(struct tcon_link *tlink)
2747{
2748 if (!tlink || IS_ERR(tlink))
2749 return;
2750
2751 if (!atomic_dec_and_test(&tlink->tl_count) ||
2752 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2753 tlink->tl_time = jiffies;
2754 return;
2755 }
2756
2757 if (!IS_ERR(tlink_tcon(tlink)))
2758 cifs_put_tcon(tlink_tcon(tlink));
2759 kfree(tlink);
2760 return;
2761}
2762
2763static inline struct tcon_link *
2764cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2765{
2766 return cifs_sb->master_tlink;
2767}
2768
2769static int
2770compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2771{
2772 struct cifs_sb_info *old = CIFS_SB(sb);
2773 struct cifs_sb_info *new = mnt_data->cifs_sb;
2774
2775 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2776 return 0;
2777
2778 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2779 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2780 return 0;
2781
2782
2783
2784
2785
2786 if (new->wsize && new->wsize < old->wsize)
2787 return 0;
2788
2789 if (new->rsize && new->rsize < old->rsize)
2790 return 0;
2791
2792 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2793 return 0;
2794
2795 if (old->mnt_file_mode != new->mnt_file_mode ||
2796 old->mnt_dir_mode != new->mnt_dir_mode)
2797 return 0;
2798
2799 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2800 return 0;
2801
2802 if (old->actimeo != new->actimeo)
2803 return 0;
2804
2805 return 1;
2806}
2807
2808static int
2809match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2810{
2811 struct cifs_sb_info *old = CIFS_SB(sb);
2812 struct cifs_sb_info *new = mnt_data->cifs_sb;
2813
2814 if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2815 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2816 return 0;
2817
2818 if (strcmp(new->prepath, old->prepath))
2819 return 0;
2820
2821 return 1;
2822 }
2823 return 0;
2824}
2825
2826int
2827cifs_match_super(struct super_block *sb, void *data)
2828{
2829 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2830 struct smb_vol *volume_info;
2831 struct cifs_sb_info *cifs_sb;
2832 struct TCP_Server_Info *tcp_srv;
2833 struct cifs_ses *ses;
2834 struct cifs_tcon *tcon;
2835 struct tcon_link *tlink;
2836 int rc = 0;
2837
2838 spin_lock(&cifs_tcp_ses_lock);
2839 cifs_sb = CIFS_SB(sb);
2840 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2841 if (IS_ERR(tlink)) {
2842 spin_unlock(&cifs_tcp_ses_lock);
2843 return rc;
2844 }
2845 tcon = tlink_tcon(tlink);
2846 ses = tcon->ses;
2847 tcp_srv = ses->server;
2848
2849 volume_info = mnt_data->vol;
2850
2851 if (!match_server(tcp_srv, volume_info) ||
2852 !match_session(ses, volume_info) ||
2853 !match_tcon(tcon, volume_info->UNC) ||
2854 !match_prepath(sb, mnt_data)) {
2855 rc = 0;
2856 goto out;
2857 }
2858
2859 rc = compare_mount_options(sb, mnt_data);
2860out:
2861 spin_unlock(&cifs_tcp_ses_lock);
2862 cifs_put_tlink(tlink);
2863 return rc;
2864}
2865
2866int
2867get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2868 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2869 struct dfs_info3_param **referrals, int remap)
2870{
2871 char *temp_unc;
2872 int rc = 0;
2873
2874 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2875 return -ENOSYS;
2876
2877 *num_referrals = 0;
2878 *referrals = NULL;
2879
2880 if (ses->ipc_tid == 0) {
2881 temp_unc = kmalloc(2 +
2882 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2883 + 1 + 4 + 2, GFP_KERNEL);
2884 if (temp_unc == NULL)
2885 return -ENOMEM;
2886 temp_unc[0] = '\\';
2887 temp_unc[1] = '\\';
2888 strcpy(temp_unc + 2, ses->serverName);
2889 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2890 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2891 nls_codepage);
2892 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2893 kfree(temp_unc);
2894 }
2895 if (rc == 0)
2896 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2897 referrals, num_referrals,
2898 nls_codepage, remap);
2899
2900
2901
2902
2903
2904 return rc;
2905}
2906
2907#ifdef CONFIG_DEBUG_LOCK_ALLOC
2908static struct lock_class_key cifs_key[2];
2909static struct lock_class_key cifs_slock_key[2];
2910
2911static inline void
2912cifs_reclassify_socket4(struct socket *sock)
2913{
2914 struct sock *sk = sock->sk;
2915 BUG_ON(!sock_allow_reclassification(sk));
2916 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2917 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2918}
2919
2920static inline void
2921cifs_reclassify_socket6(struct socket *sock)
2922{
2923 struct sock *sk = sock->sk;
2924 BUG_ON(!sock_allow_reclassification(sk));
2925 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2926 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2927}
2928#else
2929static inline void
2930cifs_reclassify_socket4(struct socket *sock)
2931{
2932}
2933
2934static inline void
2935cifs_reclassify_socket6(struct socket *sock)
2936{
2937}
2938#endif
2939
2940
2941static void rfc1002mangle(char *target, char *source, unsigned int length)
2942{
2943 unsigned int i, j;
2944
2945 for (i = 0, j = 0; i < (length); i++) {
2946
2947 target[j] = 'A' + (0x0F & (source[i] >> 4));
2948 target[j+1] = 'A' + (0x0F & source[i]);
2949 j += 2;
2950 }
2951
2952}
2953
2954static int
2955bind_socket(struct TCP_Server_Info *server)
2956{
2957 int rc = 0;
2958 if (server->srcaddr.ss_family != AF_UNSPEC) {
2959
2960 struct socket *socket = server->ssocket;
2961 rc = socket->ops->bind(socket,
2962 (struct sockaddr *) &server->srcaddr,
2963 sizeof(server->srcaddr));
2964 if (rc < 0) {
2965 struct sockaddr_in *saddr4;
2966 struct sockaddr_in6 *saddr6;
2967 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2968 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2969 if (saddr6->sin6_family == AF_INET6)
2970 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2971 &saddr6->sin6_addr, rc);
2972 else
2973 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2974 &saddr4->sin_addr.s_addr, rc);
2975 }
2976 }
2977 return rc;
2978}
2979
2980static int
2981ip_rfc1001_connect(struct TCP_Server_Info *server)
2982{
2983 int rc = 0;
2984
2985
2986
2987
2988
2989 struct rfc1002_session_packet *ses_init_buf;
2990 struct smb_hdr *smb_buf;
2991 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2992 GFP_KERNEL);
2993 if (ses_init_buf) {
2994 ses_init_buf->trailer.session_req.called_len = 32;
2995
2996 if (server->server_RFC1001_name[0] != 0)
2997 rfc1002mangle(ses_init_buf->trailer.
2998 session_req.called_name,
2999 server->server_RFC1001_name,
3000 RFC1001_NAME_LEN_WITH_NULL);
3001 else
3002 rfc1002mangle(ses_init_buf->trailer.
3003 session_req.called_name,
3004 DEFAULT_CIFS_CALLED_NAME,
3005 RFC1001_NAME_LEN_WITH_NULL);
3006
3007 ses_init_buf->trailer.session_req.calling_len = 32;
3008
3009
3010
3011
3012
3013 if (server->workstation_RFC1001_name[0] != 0)
3014 rfc1002mangle(ses_init_buf->trailer.
3015 session_req.calling_name,
3016 server->workstation_RFC1001_name,
3017 RFC1001_NAME_LEN_WITH_NULL);
3018 else
3019 rfc1002mangle(ses_init_buf->trailer.
3020 session_req.calling_name,
3021 "LINUX_CIFS_CLNT",
3022 RFC1001_NAME_LEN_WITH_NULL);
3023
3024 ses_init_buf->trailer.session_req.scope1 = 0;
3025 ses_init_buf->trailer.session_req.scope2 = 0;
3026 smb_buf = (struct smb_hdr *)ses_init_buf;
3027
3028
3029 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3030 rc = smb_send(server, smb_buf, 0x44);
3031 kfree(ses_init_buf);
3032
3033
3034
3035
3036
3037
3038
3039
3040
3041
3042 usleep_range(1000, 2000);
3043 }
3044
3045
3046
3047
3048
3049 return rc;
3050}
3051
3052static int
3053generic_ip_connect(struct TCP_Server_Info *server)
3054{
3055 int rc = 0;
3056 __be16 sport;
3057 int slen, sfamily;
3058 struct socket *socket = server->ssocket;
3059 struct sockaddr *saddr;
3060
3061 saddr = (struct sockaddr *) &server->dstaddr;
3062
3063 if (server->dstaddr.ss_family == AF_INET6) {
3064 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3065 slen = sizeof(struct sockaddr_in6);
3066 sfamily = AF_INET6;
3067 } else {
3068 sport = ((struct sockaddr_in *) saddr)->sin_port;
3069 slen = sizeof(struct sockaddr_in);
3070 sfamily = AF_INET;
3071 }
3072
3073 if (socket == NULL) {
3074 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3075 IPPROTO_TCP, &socket, 1);
3076 if (rc < 0) {
3077 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3078 server->ssocket = NULL;
3079 return rc;
3080 }
3081
3082
3083 cifs_dbg(FYI, "Socket created\n");
3084 server->ssocket = socket;
3085 socket->sk->sk_allocation = GFP_NOFS;
3086 if (sfamily == AF_INET6)
3087 cifs_reclassify_socket6(socket);
3088 else
3089 cifs_reclassify_socket4(socket);
3090 }
3091
3092 rc = bind_socket(server);
3093 if (rc < 0)
3094 return rc;
3095
3096
3097
3098
3099
3100
3101 socket->sk->sk_rcvtimeo = 7 * HZ;
3102 socket->sk->sk_sndtimeo = 5 * HZ;
3103
3104
3105 if (server->noautotune) {
3106 if (socket->sk->sk_sndbuf < (200 * 1024))
3107 socket->sk->sk_sndbuf = 200 * 1024;
3108 if (socket->sk->sk_rcvbuf < (140 * 1024))
3109 socket->sk->sk_rcvbuf = 140 * 1024;
3110 }
3111
3112 if (server->tcp_nodelay) {
3113 int val = 1;
3114 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3115 (char *)&val, sizeof(val));
3116 if (rc)
3117 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3118 rc);
3119 }
3120
3121 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3122 socket->sk->sk_sndbuf,
3123 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3124
3125 rc = socket->ops->connect(socket, saddr, slen, 0);
3126 if (rc < 0) {
3127 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3128 sock_release(socket);
3129 server->ssocket = NULL;
3130 return rc;
3131 }
3132
3133 if (sport == htons(RFC1001_PORT))
3134 rc = ip_rfc1001_connect(server);
3135
3136 return rc;
3137}
3138
3139static int
3140ip_connect(struct TCP_Server_Info *server)
3141{
3142 __be16 *sport;
3143 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3144 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3145
3146 if (server->dstaddr.ss_family == AF_INET6)
3147 sport = &addr6->sin6_port;
3148 else
3149 sport = &addr->sin_port;
3150
3151 if (*sport == 0) {
3152 int rc;
3153
3154
3155 *sport = htons(CIFS_PORT);
3156
3157 rc = generic_ip_connect(server);
3158 if (rc >= 0)
3159 return rc;
3160
3161
3162 *sport = htons(RFC1001_PORT);
3163 }
3164
3165 return generic_ip_connect(server);
3166}
3167
3168void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3169 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3170{
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3181
3182 if (vol_info && vol_info->no_linux_ext) {
3183 tcon->fsUnixInfo.Capability = 0;
3184 tcon->unix_ext = 0;
3185 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3186 return;
3187 } else if (vol_info)
3188 tcon->unix_ext = 1;
3189
3190 if (tcon->unix_ext == 0) {
3191 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3192 return;
3193 }
3194
3195 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3196 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3197 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3198
3199
3200 if (vol_info == NULL) {
3201
3202
3203 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3204 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3205 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3206 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3207 cifs_dbg(VFS, "POSIXPATH support change\n");
3208 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3209 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3210 cifs_dbg(VFS, "possible reconnect error\n");
3211 cifs_dbg(VFS, "server disabled POSIX path support\n");
3212 }
3213 }
3214
3215 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3216 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3217
3218 cap &= CIFS_UNIX_CAP_MASK;
3219 if (vol_info && vol_info->no_psx_acl)
3220 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3221 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3222 cifs_dbg(FYI, "negotiated posix acl support\n");
3223 if (cifs_sb)
3224 cifs_sb->mnt_cifs_flags |=
3225 CIFS_MOUNT_POSIXACL;
3226 }
3227
3228 if (vol_info && vol_info->posix_paths == 0)
3229 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3230 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3231 cifs_dbg(FYI, "negotiate posix pathnames\n");
3232 if (cifs_sb)
3233 cifs_sb->mnt_cifs_flags |=
3234 CIFS_MOUNT_POSIX_PATHS;
3235 }
3236
3237 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3238#ifdef CONFIG_CIFS_DEBUG2
3239 if (cap & CIFS_UNIX_FCNTL_CAP)
3240 cifs_dbg(FYI, "FCNTL cap\n");
3241 if (cap & CIFS_UNIX_EXTATTR_CAP)
3242 cifs_dbg(FYI, "EXTATTR cap\n");
3243 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3244 cifs_dbg(FYI, "POSIX path cap\n");
3245 if (cap & CIFS_UNIX_XATTR_CAP)
3246 cifs_dbg(FYI, "XATTR cap\n");
3247 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3248 cifs_dbg(FYI, "POSIX ACL cap\n");
3249 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3250 cifs_dbg(FYI, "very large read cap\n");
3251 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3252 cifs_dbg(FYI, "very large write cap\n");
3253 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3254 cifs_dbg(FYI, "transport encryption cap\n");
3255 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3256 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3257#endif
3258 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3259 if (vol_info == NULL) {
3260 cifs_dbg(FYI, "resetting capabilities failed\n");
3261 } else
3262 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");
3263
3264 }
3265 }
3266}
3267
3268int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3269 struct cifs_sb_info *cifs_sb)
3270{
3271 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3272
3273 spin_lock_init(&cifs_sb->tlink_tree_lock);
3274 cifs_sb->tlink_tree = RB_ROOT;
3275
3276
3277
3278
3279
3280 cifs_sb->rsize = pvolume_info->rsize;
3281 cifs_sb->wsize = pvolume_info->wsize;
3282
3283 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3284 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3285 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3286 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3287 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3288 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3289
3290 cifs_sb->actimeo = pvolume_info->actimeo;
3291 cifs_sb->local_nls = pvolume_info->local_nls;
3292
3293 if (pvolume_info->noperm)
3294 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3295 if (pvolume_info->setuids)
3296 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3297 if (pvolume_info->setuidfromacl)
3298 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3299 if (pvolume_info->server_ino)
3300 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3301 if (pvolume_info->remap)
3302 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3303 if (pvolume_info->sfu_remap)
3304 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3305 if (pvolume_info->no_xattr)
3306 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3307 if (pvolume_info->sfu_emul)
3308 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3309 if (pvolume_info->nobrl)
3310 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3311 if (pvolume_info->nostrictsync)
3312 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3313 if (pvolume_info->mand_lock)
3314 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3315 if (pvolume_info->rwpidforward)
3316 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3317 if (pvolume_info->cifs_acl)
3318 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3319 if (pvolume_info->backupuid_specified) {
3320 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3321 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3322 }
3323 if (pvolume_info->backupgid_specified) {
3324 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3325 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3326 }
3327 if (pvolume_info->override_uid)
3328 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3329 if (pvolume_info->override_gid)
3330 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3331 if (pvolume_info->dynperm)
3332 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3333 if (pvolume_info->fsc)
3334 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3335 if (pvolume_info->multiuser)
3336 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3337 CIFS_MOUNT_NO_PERM);
3338 if (pvolume_info->strict_io)
3339 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3340 if (pvolume_info->direct_io) {
3341 cifs_dbg(FYI, "mounting share using direct i/o\n");
3342 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3343 }
3344 if (pvolume_info->mfsymlinks) {
3345 if (pvolume_info->sfu_emul) {
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3358 }
3359 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3360 }
3361
3362 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3363 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3364
3365 if (pvolume_info->prepath) {
3366 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3367 if (cifs_sb->prepath == NULL)
3368 return -ENOMEM;
3369 }
3370
3371 return 0;
3372}
3373
3374static void
3375cleanup_volume_info_contents(struct smb_vol *volume_info)
3376{
3377 kfree(volume_info->username);
3378 kzfree(volume_info->password);
3379 kfree(volume_info->UNC);
3380 kfree(volume_info->domainname);
3381 kfree(volume_info->iocharset);
3382 kfree(volume_info->prepath);
3383}
3384
3385void
3386cifs_cleanup_volume_info(struct smb_vol *volume_info)
3387{
3388 if (!volume_info)
3389 return;
3390 cleanup_volume_info_contents(volume_info);
3391 kfree(volume_info);
3392}
3393
3394
3395#ifdef CONFIG_CIFS_DFS_UPCALL
3396
3397
3398
3399
3400static char *
3401build_unc_path_to_root(const struct smb_vol *vol,
3402 const struct cifs_sb_info *cifs_sb)
3403{
3404 char *full_path, *pos;
3405 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3406 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3407
3408 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3409 if (full_path == NULL)
3410 return ERR_PTR(-ENOMEM);
3411
3412 strncpy(full_path, vol->UNC, unc_len);
3413 pos = full_path + unc_len;
3414
3415 if (pplen) {
3416 *pos = CIFS_DIR_SEP(cifs_sb);
3417 strncpy(pos + 1, vol->prepath, pplen);
3418 pos += pplen;
3419 }
3420
3421 *pos = '\0';
3422 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3423 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3424 return full_path;
3425}
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437static int
3438expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3439 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3440 int check_prefix)
3441{
3442 int rc;
3443 unsigned int num_referrals = 0;
3444 struct dfs_info3_param *referrals = NULL;
3445 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3446
3447 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3448 if (IS_ERR(full_path))
3449 return PTR_ERR(full_path);
3450
3451
3452 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3453
3454 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3455 &num_referrals, &referrals, cifs_remap(cifs_sb));
3456
3457 if (!rc && num_referrals > 0) {
3458 char *fake_devname = NULL;
3459
3460 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3461 full_path + 1, referrals,
3462 &fake_devname);
3463
3464 free_dfs_info_array(referrals, num_referrals);
3465
3466 if (IS_ERR(mdata)) {
3467 rc = PTR_ERR(mdata);
3468 mdata = NULL;
3469 } else {
3470 cleanup_volume_info_contents(volume_info);
3471 rc = cifs_setup_volume_info(volume_info, mdata,
3472 fake_devname);
3473 }
3474 kfree(fake_devname);
3475 kfree(cifs_sb->mountdata);
3476 cifs_sb->mountdata = mdata;
3477 }
3478 kfree(full_path);
3479 return rc;
3480}
3481#endif
3482
3483static int
3484cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3485 const char *devname)
3486{
3487 int rc = 0;
3488
3489 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3490 return -EINVAL;
3491
3492 if (volume_info->nullauth) {
3493 cifs_dbg(FYI, "Anonymous login\n");
3494 kfree(volume_info->username);
3495 volume_info->username = NULL;
3496 } else if (volume_info->username) {
3497
3498 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3499 } else {
3500 cifs_dbg(VFS, "No username specified\n");
3501
3502
3503 return -EINVAL;
3504 }
3505
3506
3507 if (volume_info->iocharset == NULL) {
3508
3509 volume_info->local_nls = load_nls_default();
3510 } else {
3511 volume_info->local_nls = load_nls(volume_info->iocharset);
3512 if (volume_info->local_nls == NULL) {
3513 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3514 volume_info->iocharset);
3515 return -ELIBACC;
3516 }
3517 }
3518
3519 return rc;
3520}
3521
3522struct smb_vol *
3523cifs_get_volume_info(char *mount_data, const char *devname)
3524{
3525 int rc;
3526 struct smb_vol *volume_info;
3527
3528 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3529 if (!volume_info)
3530 return ERR_PTR(-ENOMEM);
3531
3532 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3533 if (rc) {
3534 cifs_cleanup_volume_info(volume_info);
3535 volume_info = ERR_PTR(rc);
3536 }
3537
3538 return volume_info;
3539}
3540
3541static int
3542cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3543 unsigned int xid,
3544 struct cifs_tcon *tcon,
3545 struct cifs_sb_info *cifs_sb,
3546 char *full_path)
3547{
3548 int rc;
3549 char *s;
3550 char sep, tmp;
3551
3552 sep = CIFS_DIR_SEP(cifs_sb);
3553 s = full_path;
3554
3555 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3556 while (rc == 0) {
3557
3558 while (*s == sep)
3559 s++;
3560 if (!*s)
3561 break;
3562
3563 while (*s && *s != sep)
3564 s++;
3565
3566
3567
3568
3569
3570 tmp = *s;
3571 *s = 0;
3572 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3573 full_path);
3574 *s = tmp;
3575 }
3576 return rc;
3577}
3578
3579int
3580cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3581{
3582 int rc;
3583 unsigned int xid;
3584 struct cifs_ses *ses;
3585 struct cifs_tcon *tcon;
3586 struct TCP_Server_Info *server;
3587 char *full_path;
3588 struct tcon_link *tlink;
3589#ifdef CONFIG_CIFS_DFS_UPCALL
3590 int referral_walks_count = 0;
3591#endif
3592
3593 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3594 if (rc)
3595 return rc;
3596
3597#ifdef CONFIG_CIFS_DFS_UPCALL
3598try_mount_again:
3599
3600 if (referral_walks_count) {
3601 if (tcon)
3602 cifs_put_tcon(tcon);
3603 else if (ses)
3604 cifs_put_smb_ses(ses);
3605
3606 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3607
3608 free_xid(xid);
3609 }
3610#endif
3611 rc = 0;
3612 tcon = NULL;
3613 ses = NULL;
3614 server = NULL;
3615 full_path = NULL;
3616 tlink = NULL;
3617
3618 xid = get_xid();
3619
3620
3621 server = cifs_get_tcp_session(volume_info);
3622 if (IS_ERR(server)) {
3623 rc = PTR_ERR(server);
3624 bdi_destroy(&cifs_sb->bdi);
3625 goto out;
3626 }
3627 if ((volume_info->max_credits < 20) ||
3628 (volume_info->max_credits > 60000))
3629 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3630 else
3631 server->max_credits = volume_info->max_credits;
3632
3633 ses = cifs_get_smb_ses(server, volume_info);
3634 if (IS_ERR(ses)) {
3635 rc = PTR_ERR(ses);
3636 ses = NULL;
3637 goto mount_fail_check;
3638 }
3639
3640#ifdef CONFIG_CIFS_SMB2
3641 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3642 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3643 cifs_dbg(VFS, "persistent handles not supported by server\n");
3644 rc = -EOPNOTSUPP;
3645 goto mount_fail_check;
3646 }
3647#endif
3648
3649
3650 tcon = cifs_get_tcon(ses, volume_info);
3651 if (IS_ERR(tcon)) {
3652 rc = PTR_ERR(tcon);
3653 tcon = NULL;
3654 goto remote_path_check;
3655 }
3656
3657
3658 if (cap_unix(tcon->ses)) {
3659
3660
3661 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3662 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3663 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3664 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3665 rc = -EACCES;
3666 goto mount_fail_check;
3667 }
3668 } else
3669 tcon->unix_ext = 0;
3670
3671
3672 if (!tcon->ipc && server->ops->qfs_tcon)
3673 server->ops->qfs_tcon(xid, tcon);
3674
3675 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3676 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3677
3678
3679 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3680
3681remote_path_check:
3682#ifdef CONFIG_CIFS_DFS_UPCALL
3683
3684
3685
3686
3687
3688
3689
3690 if (referral_walks_count == 0) {
3691 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3692 false);
3693 if (!refrc) {
3694 referral_walks_count++;
3695 goto try_mount_again;
3696 }
3697 }
3698#endif
3699
3700
3701 if (!rc && tcon) {
3702 if (!server->ops->is_path_accessible) {
3703 rc = -ENOSYS;
3704 goto mount_fail_check;
3705 }
3706
3707
3708
3709 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3710 if (full_path == NULL) {
3711 rc = -ENOMEM;
3712 goto mount_fail_check;
3713 }
3714 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3715 full_path);
3716 if (rc != 0 && rc != -EREMOTE) {
3717 kfree(full_path);
3718 goto mount_fail_check;
3719 }
3720
3721 if (rc != -EREMOTE) {
3722 rc = cifs_are_all_path_components_accessible(server,
3723 xid, tcon, cifs_sb,
3724 full_path);
3725 if (rc != 0) {
3726 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3727 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3728 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3729 rc = 0;
3730 }
3731 }
3732 kfree(full_path);
3733 }
3734
3735
3736 if (rc == -EREMOTE) {
3737#ifdef CONFIG_CIFS_DFS_UPCALL
3738 if (referral_walks_count > MAX_NESTED_LINKS) {
3739
3740
3741
3742
3743
3744
3745 rc = -ELOOP;
3746 goto mount_fail_check;
3747 }
3748
3749 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3750
3751 if (!rc) {
3752 referral_walks_count++;
3753 goto try_mount_again;
3754 }
3755 goto mount_fail_check;
3756#else
3757 rc = -EOPNOTSUPP;
3758#endif
3759 }
3760
3761 if (rc)
3762 goto mount_fail_check;
3763
3764
3765 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3766 if (tlink == NULL) {
3767 rc = -ENOMEM;
3768 goto mount_fail_check;
3769 }
3770
3771 tlink->tl_uid = ses->linux_uid;
3772 tlink->tl_tcon = tcon;
3773 tlink->tl_time = jiffies;
3774 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3775 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3776
3777 cifs_sb->master_tlink = tlink;
3778 spin_lock(&cifs_sb->tlink_tree_lock);
3779 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3780 spin_unlock(&cifs_sb->tlink_tree_lock);
3781
3782 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3783 TLINK_IDLE_EXPIRE);
3784
3785mount_fail_check:
3786
3787 if (rc) {
3788
3789
3790 if (tcon)
3791 cifs_put_tcon(tcon);
3792 else if (ses)
3793 cifs_put_smb_ses(ses);
3794 else
3795 cifs_put_tcp_session(server);
3796 bdi_destroy(&cifs_sb->bdi);
3797 }
3798
3799out:
3800 free_xid(xid);
3801 return rc;
3802}
3803
3804
3805
3806
3807
3808int
3809CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3810 const char *tree, struct cifs_tcon *tcon,
3811 const struct nls_table *nls_codepage)
3812{
3813 struct smb_hdr *smb_buffer;
3814 struct smb_hdr *smb_buffer_response;
3815 TCONX_REQ *pSMB;
3816 TCONX_RSP *pSMBr;
3817 unsigned char *bcc_ptr;
3818 int rc = 0;
3819 int length;
3820 __u16 bytes_left, count;
3821
3822 if (ses == NULL)
3823 return -EIO;
3824
3825 smb_buffer = cifs_buf_get();
3826 if (smb_buffer == NULL)
3827 return -ENOMEM;
3828
3829 smb_buffer_response = smb_buffer;
3830
3831 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3832 NULL , 4 );
3833
3834 smb_buffer->Mid = get_next_mid(ses->server);
3835 smb_buffer->Uid = ses->Suid;
3836 pSMB = (TCONX_REQ *) smb_buffer;
3837 pSMBr = (TCONX_RSP *) smb_buffer_response;
3838
3839 pSMB->AndXCommand = 0xFF;
3840 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3841 bcc_ptr = &pSMB->Password[0];
3842 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3843 pSMB->PasswordLength = cpu_to_le16(1);
3844 *bcc_ptr = 0;
3845 bcc_ptr++;
3846
3847 } else {
3848 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3849
3850
3851
3852
3853
3854
3855#ifdef CONFIG_CIFS_WEAK_PW_HASH
3856 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3857 (ses->sectype == LANMAN))
3858 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3859 ses->server->sec_mode &
3860 SECMODE_PW_ENCRYPT ? true : false,
3861 bcc_ptr);
3862 else
3863#endif
3864 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3865 bcc_ptr, nls_codepage);
3866 if (rc) {
3867 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3868 __func__, rc);
3869 cifs_buf_release(smb_buffer);
3870 return rc;
3871 }
3872
3873 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3874 if (ses->capabilities & CAP_UNICODE) {
3875
3876 *bcc_ptr = 0;
3877 bcc_ptr++;
3878 }
3879 }
3880
3881 if (ses->server->sign)
3882 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3883
3884 if (ses->capabilities & CAP_STATUS32) {
3885 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3886 }
3887 if (ses->capabilities & CAP_DFS) {
3888 smb_buffer->Flags2 |= SMBFLG2_DFS;
3889 }
3890 if (ses->capabilities & CAP_UNICODE) {
3891 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3892 length =
3893 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3894 6 *
3895 ( + 256 ), nls_codepage);
3896 bcc_ptr += 2 * length;
3897 bcc_ptr += 2;
3898 } else {
3899 strcpy(bcc_ptr, tree);
3900 bcc_ptr += strlen(tree) + 1;
3901 }
3902 strcpy(bcc_ptr, "?????");
3903 bcc_ptr += strlen("?????");
3904 bcc_ptr += 1;
3905 count = bcc_ptr - &pSMB->Password[0];
3906 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3907 pSMB->hdr.smb_buf_length) + count);
3908 pSMB->ByteCount = cpu_to_le16(count);
3909
3910 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3911 0);
3912
3913
3914 if ((rc == 0) && (tcon != NULL)) {
3915 bool is_unicode;
3916
3917 tcon->tidStatus = CifsGood;
3918 tcon->need_reconnect = false;
3919 tcon->tid = smb_buffer_response->Tid;
3920 bcc_ptr = pByteArea(smb_buffer_response);
3921 bytes_left = get_bcc(smb_buffer_response);
3922 length = strnlen(bcc_ptr, bytes_left - 2);
3923 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3924 is_unicode = true;
3925 else
3926 is_unicode = false;
3927
3928
3929
3930 if (length == 3) {
3931 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3932 (bcc_ptr[2] == 'C')) {
3933 cifs_dbg(FYI, "IPC connection\n");
3934 tcon->ipc = 1;
3935 }
3936 } else if (length == 2) {
3937 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3938
3939 cifs_dbg(FYI, "disk share connection\n");
3940 }
3941 }
3942 bcc_ptr += length + 1;
3943 bytes_left -= (length + 1);
3944 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3945
3946
3947 kfree(tcon->nativeFileSystem);
3948 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3949 bytes_left, is_unicode,
3950 nls_codepage);
3951
3952 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3953
3954 if ((smb_buffer_response->WordCount == 3) ||
3955 (smb_buffer_response->WordCount == 7))
3956
3957 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3958 else
3959 tcon->Flags = 0;
3960 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3961 } else if ((rc == 0) && tcon == NULL) {
3962
3963 ses->ipc_tid = smb_buffer_response->Tid;
3964 }
3965
3966 cifs_buf_release(smb_buffer);
3967 return rc;
3968}
3969
3970static void delayed_free(struct rcu_head *p)
3971{
3972 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3973 unload_nls(sbi->local_nls);
3974 kfree(sbi);
3975}
3976
3977void
3978cifs_umount(struct cifs_sb_info *cifs_sb)
3979{
3980 struct rb_root *root = &cifs_sb->tlink_tree;
3981 struct rb_node *node;
3982 struct tcon_link *tlink;
3983
3984 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3985
3986 spin_lock(&cifs_sb->tlink_tree_lock);
3987 while ((node = rb_first(root))) {
3988 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3989 cifs_get_tlink(tlink);
3990 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3991 rb_erase(node, root);
3992
3993 spin_unlock(&cifs_sb->tlink_tree_lock);
3994 cifs_put_tlink(tlink);
3995 spin_lock(&cifs_sb->tlink_tree_lock);
3996 }
3997 spin_unlock(&cifs_sb->tlink_tree_lock);
3998
3999 bdi_destroy(&cifs_sb->bdi);
4000 kfree(cifs_sb->mountdata);
4001 kfree(cifs_sb->prepath);
4002 call_rcu(&cifs_sb->rcu, delayed_free);
4003}
4004
4005int
4006cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4007{
4008 int rc = 0;
4009 struct TCP_Server_Info *server = ses->server;
4010
4011 if (!server->ops->need_neg || !server->ops->negotiate)
4012 return -ENOSYS;
4013
4014
4015 if (!server->ops->need_neg(server))
4016 return 0;
4017
4018 set_credits(server, 1);
4019
4020 rc = server->ops->negotiate(xid, ses);
4021 if (rc == 0) {
4022 spin_lock(&GlobalMid_Lock);
4023 if (server->tcpStatus == CifsNeedNegotiate)
4024 server->tcpStatus = CifsGood;
4025 else
4026 rc = -EHOSTDOWN;
4027 spin_unlock(&GlobalMid_Lock);
4028 }
4029
4030 return rc;
4031}
4032
4033int
4034cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4035 struct nls_table *nls_info)
4036{
4037 int rc = -ENOSYS;
4038 struct TCP_Server_Info *server = ses->server;
4039
4040 ses->capabilities = server->capabilities;
4041 if (linuxExtEnabled == 0)
4042 ses->capabilities &= (~server->vals->cap_unix);
4043
4044 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4045 server->sec_mode, server->capabilities, server->timeAdj);
4046
4047 if (server->ops->sess_setup)
4048 rc = server->ops->sess_setup(xid, ses, nls_info);
4049
4050 if (rc)
4051 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4052
4053 return rc;
4054}
4055
4056static int
4057cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4058{
4059 vol->sectype = ses->sectype;
4060
4061
4062 if (vol->sectype == Kerberos)
4063 return 0;
4064
4065 return cifs_set_cifscreds(vol, ses);
4066}
4067
4068static struct cifs_tcon *
4069cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4070{
4071 int rc;
4072 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4073 struct cifs_ses *ses;
4074 struct cifs_tcon *tcon = NULL;
4075 struct smb_vol *vol_info;
4076
4077 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4078 if (vol_info == NULL)
4079 return ERR_PTR(-ENOMEM);
4080
4081 vol_info->local_nls = cifs_sb->local_nls;
4082 vol_info->linux_uid = fsuid;
4083 vol_info->cred_uid = fsuid;
4084 vol_info->UNC = master_tcon->treeName;
4085 vol_info->retry = master_tcon->retry;
4086 vol_info->nocase = master_tcon->nocase;
4087 vol_info->local_lease = master_tcon->local_lease;
4088 vol_info->no_linux_ext = !master_tcon->unix_ext;
4089 vol_info->sectype = master_tcon->ses->sectype;
4090 vol_info->sign = master_tcon->ses->sign;
4091
4092 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4093 if (rc) {
4094 tcon = ERR_PTR(rc);
4095 goto out;
4096 }
4097
4098
4099 spin_lock(&cifs_tcp_ses_lock);
4100 ++master_tcon->ses->server->srv_count;
4101 spin_unlock(&cifs_tcp_ses_lock);
4102
4103 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4104 if (IS_ERR(ses)) {
4105 tcon = (struct cifs_tcon *)ses;
4106 cifs_put_tcp_session(master_tcon->ses->server);
4107 goto out;
4108 }
4109
4110 tcon = cifs_get_tcon(ses, vol_info);
4111 if (IS_ERR(tcon)) {
4112 cifs_put_smb_ses(ses);
4113 goto out;
4114 }
4115
4116 if (cap_unix(ses))
4117 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4118out:
4119 kfree(vol_info->username);
4120 kfree(vol_info->password);
4121 kfree(vol_info);
4122
4123 return tcon;
4124}
4125
4126struct cifs_tcon *
4127cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4128{
4129 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4130}
4131
4132
4133static struct tcon_link *
4134tlink_rb_search(struct rb_root *root, kuid_t uid)
4135{
4136 struct rb_node *node = root->rb_node;
4137 struct tcon_link *tlink;
4138
4139 while (node) {
4140 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4141
4142 if (uid_gt(tlink->tl_uid, uid))
4143 node = node->rb_left;
4144 else if (uid_lt(tlink->tl_uid, uid))
4145 node = node->rb_right;
4146 else
4147 return tlink;
4148 }
4149 return NULL;
4150}
4151
4152
4153static void
4154tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4155{
4156 struct rb_node **new = &(root->rb_node), *parent = NULL;
4157 struct tcon_link *tlink;
4158
4159 while (*new) {
4160 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4161 parent = *new;
4162
4163 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4164 new = &((*new)->rb_left);
4165 else
4166 new = &((*new)->rb_right);
4167 }
4168
4169 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4170 rb_insert_color(&new_tlink->tl_rbnode, root);
4171}
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189struct tcon_link *
4190cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4191{
4192 int ret;
4193 kuid_t fsuid = current_fsuid();
4194 struct tcon_link *tlink, *newtlink;
4195
4196 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4197 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4198
4199 spin_lock(&cifs_sb->tlink_tree_lock);
4200 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4201 if (tlink)
4202 cifs_get_tlink(tlink);
4203 spin_unlock(&cifs_sb->tlink_tree_lock);
4204
4205 if (tlink == NULL) {
4206 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4207 if (newtlink == NULL)
4208 return ERR_PTR(-ENOMEM);
4209 newtlink->tl_uid = fsuid;
4210 newtlink->tl_tcon = ERR_PTR(-EACCES);
4211 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4212 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4213 cifs_get_tlink(newtlink);
4214
4215 spin_lock(&cifs_sb->tlink_tree_lock);
4216
4217 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4218 if (tlink) {
4219 cifs_get_tlink(tlink);
4220 spin_unlock(&cifs_sb->tlink_tree_lock);
4221 kfree(newtlink);
4222 goto wait_for_construction;
4223 }
4224 tlink = newtlink;
4225 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4226 spin_unlock(&cifs_sb->tlink_tree_lock);
4227 } else {
4228wait_for_construction:
4229 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4230 TASK_INTERRUPTIBLE);
4231 if (ret) {
4232 cifs_put_tlink(tlink);
4233 return ERR_PTR(-ERESTARTSYS);
4234 }
4235
4236
4237 if (!IS_ERR(tlink->tl_tcon))
4238 return tlink;
4239
4240
4241 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4242 cifs_put_tlink(tlink);
4243 return ERR_PTR(-EACCES);
4244 }
4245
4246 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4247 goto wait_for_construction;
4248 }
4249
4250 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4251 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4252 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4253
4254 if (IS_ERR(tlink->tl_tcon)) {
4255 cifs_put_tlink(tlink);
4256 return ERR_PTR(-EACCES);
4257 }
4258
4259 return tlink;
4260}
4261
4262
4263
4264
4265
4266static void
4267cifs_prune_tlinks(struct work_struct *work)
4268{
4269 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4270 prune_tlinks.work);
4271 struct rb_root *root = &cifs_sb->tlink_tree;
4272 struct rb_node *node = rb_first(root);
4273 struct rb_node *tmp;
4274 struct tcon_link *tlink;
4275
4276
4277
4278
4279
4280
4281
4282
4283 spin_lock(&cifs_sb->tlink_tree_lock);
4284 node = rb_first(root);
4285 while (node != NULL) {
4286 tmp = node;
4287 node = rb_next(tmp);
4288 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4289
4290 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4291 atomic_read(&tlink->tl_count) != 0 ||
4292 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4293 continue;
4294
4295 cifs_get_tlink(tlink);
4296 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4297 rb_erase(tmp, root);
4298
4299 spin_unlock(&cifs_sb->tlink_tree_lock);
4300 cifs_put_tlink(tlink);
4301 spin_lock(&cifs_sb->tlink_tree_lock);
4302 }
4303 spin_unlock(&cifs_sb->tlink_tree_lock);
4304
4305 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4306 TLINK_IDLE_EXPIRE);
4307}
4308