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