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