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