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