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