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