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                         if (value != NULL)
1569                                 *value++ = '\0';
1570
1571                         /* Set tmp_end to end of the string */
1572                         tmp_end = (char *) value + strlen(value);
1573
1574                         /* Check if following character is the deliminator
1575                          * If yes, we have encountered a double deliminator
1576                          * reset the NULL character to the deliminator
1577                          */
1578                         if (tmp_end < end && tmp_end[1] == delim)
1579                                 tmp_end[0] = delim;
1580
1581                         /* Keep iterating until we get to a single deliminator
1582                          * OR the end
1583                          */
1584                         while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
1585                                (tmp_end[1] == delim)) {
1586                                 tmp_end = (char *) &tmp_end[2];
1587                         }
1588
1589                         /* Reset var options to point to next element */
1590                         if (tmp_end) {
1591                                 tmp_end[0] = '\0';
1592                                 options = (char *) &tmp_end[1];
1593                         } else
1594                                 /* Reached the end of the mount option string */
1595                                 options = end;
1596
1597                         /* Now build new password string */
1598                         temp_len = strlen(value);
1599                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1600                         if (vol->password == NULL) {
1601                                 printk(KERN_WARNING "CIFS: no memory "
1602                                                     "for password\n");
1603                                 goto cifs_parse_mount_err;
1604                         }
1605
1606                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1607                                 vol->password[j] = value[i];
1608                                 if ((value[i] == delim) &&
1609                                      value[i+1] == delim)
1610                                         /* skip the second deliminator */
1611                                         i++;
1612                         }
1613                         vol->password[j] = '\0';
1614                         break;
1615                 case Opt_ip:
1616                         string = match_strdup(args);
1617                         if (string == NULL)
1618                                 goto out_nomem;
1619
1620                         if (!*string) {
1621                                 vol->UNCip = NULL;
1622                         } else if (strnlen(string, INET6_ADDRSTRLEN) >
1623                                                 INET6_ADDRSTRLEN) {
1624                                 printk(KERN_WARNING "CIFS: ip address "
1625                                                     "too long\n");
1626                                 goto cifs_parse_mount_err;
1627                         }
1628                         vol->UNCip = kstrdup(string, GFP_KERNEL);
1629                         if (!vol->UNCip) {
1630                                 printk(KERN_WARNING "CIFS: no memory "
1631                                                     "for UNC IP\n");
1632                                 goto cifs_parse_mount_err;
1633                         }
1634                         break;
1635                 case Opt_unc:
1636                         string = match_strdup(args);
1637                         if (string == NULL)
1638                                 goto out_nomem;
1639
1640                         if (!*string) {
1641                                 printk(KERN_WARNING "CIFS: invalid path to "
1642                                                     "network resource\n");
1643                                 goto cifs_parse_mount_err;
1644                         }
1645
1646                         temp_len = strnlen(string, 300);
1647                         if (temp_len  == 300) {
1648                                 printk(KERN_WARNING "CIFS: UNC name too long\n");
1649                                 goto cifs_parse_mount_err;
1650                         }
1651
1652                         if (strncmp(string, "//", 2) == 0) {
1653                                 vol->UNC[0] = '\\';
1654                                 vol->UNC[1] = '\\';
1655                         } else if (strncmp(string, "\\\\", 2) != 0) {
1656                                 printk(KERN_WARNING "CIFS: UNC Path does not "
1657                                                     "begin with // or \\\\\n");
1658                                 goto cifs_parse_mount_err;
1659                         }
1660
1661                         vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1662                         if (vol->UNC == NULL) {
1663                                 printk(KERN_WARNING "CIFS: no memory "
1664                                                     "for UNC\n");
1665                                 goto cifs_parse_mount_err;
1666                         }
1667                         strcpy(vol->UNC, string);
1668                         break;
1669                 case Opt_domain:
1670                         string = match_strdup(args);
1671                         if (string == NULL)
1672                                 goto out_nomem;
1673
1674                         if (!*string) {
1675                                 printk(KERN_WARNING "CIFS: invalid domain"
1676                                                     " name\n");
1677                                 goto cifs_parse_mount_err;
1678                         } else if (strnlen(string, 256) == 256) {
1679                                 printk(KERN_WARNING "CIFS: domain name too"
1680                                                     " long\n");
1681                                 goto cifs_parse_mount_err;
1682                         }
1683
1684                         vol->domainname = kstrdup(string, GFP_KERNEL);
1685                         if (!vol->domainname) {
1686                                 printk(KERN_WARNING "CIFS: no memory "
1687                                                     "for domainname\n");
1688                                 goto cifs_parse_mount_err;
1689                         }
1690                         cFYI(1, "Domain name set");
1691                         break;
1692                 case Opt_srcaddr:
1693                         string = match_strdup(args);
1694                         if (string == NULL)
1695                                 goto out_nomem;
1696
1697                         if (!*string) {
1698                                 printk(KERN_WARNING "CIFS: srcaddr value not"
1699                                                     " specified\n");
1700                                 goto cifs_parse_mount_err;
1701                         } else if (!cifs_convert_address(
1702                                         (struct sockaddr *)&vol->srcaddr,
1703                                         string, strlen(string))) {
1704                                 printk(KERN_WARNING "CIFS:  Could not parse"
1705                                                     " srcaddr: %s\n", string);
1706                                 goto cifs_parse_mount_err;
1707                         }
1708                         break;
1709                 case Opt_prefixpath:
1710                         string = match_strdup(args);
1711                         if (string == NULL)
1712                                 goto out_nomem;
1713
1714                         if (!*string) {
1715                                 printk(KERN_WARNING "CIFS: Invalid path"
1716                                                     " prefix\n");
1717                                 goto cifs_parse_mount_err;
1718                         }
1719                         temp_len = strnlen(string, 1024);
1720                         if (string[0] != '/')
1721                                 temp_len++; /* missing leading slash */
1722                         if (temp_len > 1024) {
1723                                 printk(KERN_WARNING "CIFS: prefix too long\n");
1724                                 goto cifs_parse_mount_err;
1725                         }
1726
1727                         vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1728                         if (vol->prepath == NULL) {
1729                                 printk(KERN_WARNING "CIFS: no memory "
1730                                                     "for path prefix\n");
1731                                 goto cifs_parse_mount_err;
1732                         }
1733
1734                         if (string[0] != '/') {
1735                                 vol->prepath[0] = '/';
1736                                 strcpy(vol->prepath+1, string);
1737                         } else
1738                                 strcpy(vol->prepath, string);
1739
1740                         break;
1741                 case Opt_iocharset:
1742                         string = match_strdup(args);
1743                         if (string == NULL)
1744                                 goto out_nomem;
1745
1746                         if (!*string) {
1747                                 printk(KERN_WARNING "CIFS: Invalid iocharset"
1748                                                     " specified\n");
1749                                 goto cifs_parse_mount_err;
1750                         } else if (strnlen(string, 1024) >= 65) {
1751                                 printk(KERN_WARNING "CIFS: iocharset name "
1752                                                     "too long.\n");
1753                                 goto cifs_parse_mount_err;
1754                         }
1755
1756                          if (strnicmp(string, "default", 7) != 0) {
1757                                 vol->iocharset = kstrdup(string,
1758                                                          GFP_KERNEL);
1759                                 if (!vol->iocharset) {
1760                                         printk(KERN_WARNING "CIFS: no memory"
1761                                                             "for charset\n");
1762                                         goto cifs_parse_mount_err;
1763                                 }
1764                         }
1765                         /* if iocharset not set then load_nls_default
1766                          * is used by caller
1767                          */
1768                         cFYI(1, "iocharset set to %s", string);
1769                         break;
1770                 case Opt_sockopt:
1771                         string = match_strdup(args);
1772                         if (string == NULL)
1773                                 goto out_nomem;
1774
1775                         if (!*string) {
1776                                 printk(KERN_WARNING "CIFS: No socket option"
1777                                                     " specified\n");
1778                                 goto cifs_parse_mount_err;
1779                         }
1780                         if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1781                                 vol->sockopt_tcp_nodelay = 1;
1782                         break;
1783                 case Opt_netbiosname:
1784                         string = match_strdup(args);
1785                         if (string == NULL)
1786                                 goto out_nomem;
1787
1788                         if (!*string) {
1789                                 printk(KERN_WARNING "CIFS: Invalid (empty)"
1790                                                     " netbiosname\n");
1791                                 break;
1792                         }
1793
1794                         memset(vol->source_rfc1001_name, 0x20,
1795                                 RFC1001_NAME_LEN);
1796                         /*
1797                          * FIXME: are there cases in which a comma can
1798                          * be valid in workstation netbios name (and
1799                          * need special handling)?
1800                          */
1801                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1802                                 /* don't ucase netbiosname for user */
1803                                 if (string[i] == 0)
1804                                         break;
1805                                 vol->source_rfc1001_name[i] = string[i];
1806                         }
1807                         /* The string has 16th byte zero still from
1808                          * set at top of the function
1809                          */
1810                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1811                                 printk(KERN_WARNING "CIFS: netbiosname"
1812                                        " longer than 15 truncated.\n");
1813
1814                         break;
1815                 case Opt_servern:
1816                         /* servernetbiosname specified override *SMBSERVER */
1817                         string = match_strdup(args);
1818                         if (string == NULL)
1819                                 goto out_nomem;
1820
1821                         if (!*string) {
1822                                 printk(KERN_WARNING "CIFS: Empty server"
1823                                         " netbiosname specified\n");
1824                                 break;
1825                         }
1826                         /* last byte, type, is 0x20 for servr type */
1827                         memset(vol->target_rfc1001_name, 0x20,
1828                                 RFC1001_NAME_LEN_WITH_NULL);
1829
1830                         /* BB are there cases in which a comma can be
1831                            valid in this workstation netbios name
1832                            (and need special handling)? */
1833
1834                         /* user or mount helper must uppercase the
1835                            netbios name */
1836                         for (i = 0; i < 15; i++) {
1837                                 if (string[i] == 0)
1838                                         break;
1839                                 vol->target_rfc1001_name[i] = string[i];
1840                         }
1841                         /* The string has 16th byte zero still from
1842                            set at top of the function  */
1843                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1844                                 printk(KERN_WARNING "CIFS: server net"
1845                                        "biosname longer than 15 truncated.\n");
1846                         break;
1847                 case Opt_ver:
1848                         string = match_strdup(args);
1849                         if (string == NULL)
1850                                 goto out_nomem;
1851
1852                         if (!*string) {
1853                                 cERROR(1, "no protocol version specified"
1854                                           " after vers= mount option");
1855                                 goto cifs_parse_mount_err;
1856                         }
1857
1858                         if (strnicmp(string, "cifs", 4) == 0 ||
1859                             strnicmp(string, "1", 1) == 0) {
1860                                 /* This is the default */
1861                                 break;
1862                         }
1863                         /* For all other value, error */
1864                         printk(KERN_WARNING "CIFS: Invalid version"
1865                                             " specified\n");
1866                         goto cifs_parse_mount_err;
1867                 case Opt_sec:
1868                         string = match_strdup(args);
1869                         if (string == NULL)
1870                                 goto out_nomem;
1871
1872                         if (!*string) {
1873                                 printk(KERN_WARNING "CIFS: no security flavor"
1874                                                     " specified\n");
1875                                 break;
1876                         }
1877
1878                         if (cifs_parse_security_flavors(string, vol) != 0)
1879                                 goto cifs_parse_mount_err;
1880                         break;
1881                 default:
1882                         /*
1883                          * An option we don't recognize. Save it off for later
1884                          * if we haven't already found one
1885                          */
1886                         if (!invalid)
1887                                 invalid = data;
1888                         break;
1889                 }
1890                 /* Free up any allocated string */
1891                 kfree(string);
1892                 string = NULL;
1893         }
1894
1895         if (!sloppy && invalid) {
1896                 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1897                 goto cifs_parse_mount_err;
1898         }
1899
1900 #ifndef CONFIG_KEYS
1901         /* Muliuser mounts require CONFIG_KEYS support */
1902         if (vol->multiuser) {
1903                 cERROR(1, "Multiuser mounts require kernels with "
1904                           "CONFIG_KEYS enabled.");
1905                 goto cifs_parse_mount_err;
1906         }
1907 #endif
1908
1909         if (vol->UNCip == NULL)
1910                 vol->UNCip = &vol->UNC[2];
1911
1912         if (uid_specified)
1913                 vol->override_uid = override_uid;
1914         else if (override_uid == 1)
1915                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1916                                    "specified with no uid= option.\n");
1917
1918         if (gid_specified)
1919                 vol->override_gid = override_gid;
1920         else if (override_gid == 1)
1921                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1922                                    "specified with no gid= option.\n");
1923
1924         kfree(mountdata_copy);
1925         return 0;
1926
1927 out_nomem:
1928         printk(KERN_WARNING "Could not allocate temporary buffer\n");
1929 cifs_parse_mount_err:
1930         kfree(string);
1931         kfree(mountdata_copy);
1932         return 1;
1933 }
1934
1935 /** Returns true if srcaddr isn't specified and rhs isn't
1936  * specified, or if srcaddr is specified and
1937  * matches the IP address of the rhs argument.
1938  */
1939 static bool
1940 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1941 {
1942         switch (srcaddr->sa_family) {
1943         case AF_UNSPEC:
1944                 return (rhs->sa_family == AF_UNSPEC);
1945         case AF_INET: {
1946                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1947                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1948                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1949         }
1950         case AF_INET6: {
1951                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1952                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1953                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1954         }
1955         default:
1956                 WARN_ON(1);
1957                 return false; /* don't expect to be here */
1958         }
1959 }
1960
1961 /*
1962  * If no port is specified in addr structure, we try to match with 445 port
1963  * and if it fails - with 139 ports. It should be called only if address
1964  * families of server and addr are equal.
1965  */
1966 static bool
1967 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1968 {
1969         __be16 port, *sport;
1970
1971         switch (addr->sa_family) {
1972         case AF_INET:
1973                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1974                 port = ((struct sockaddr_in *) addr)->sin_port;
1975                 break;
1976         case AF_INET6:
1977                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1978                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1979                 break;
1980         default:
1981                 WARN_ON(1);
1982                 return false;
1983         }
1984
1985         if (!port) {
1986                 port = htons(CIFS_PORT);
1987                 if (port == *sport)
1988                         return true;
1989
1990                 port = htons(RFC1001_PORT);
1991         }
1992
1993         return port == *sport;
1994 }
1995
1996 static bool
1997 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1998               struct sockaddr *srcaddr)
1999 {
2000         switch (addr->sa_family) {
2001         case AF_INET: {
2002                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2003                 struct sockaddr_in *srv_addr4 =
2004                                         (struct sockaddr_in *)&server->dstaddr;
2005
2006                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2007                         return false;
2008                 break;
2009         }
2010         case AF_INET6: {
2011                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2012                 struct sockaddr_in6 *srv_addr6 =
2013                                         (struct sockaddr_in6 *)&server->dstaddr;
2014
2015                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2016                                      &srv_addr6->sin6_addr))
2017                         return false;
2018                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2019                         return false;
2020                 break;
2021         }
2022         default:
2023                 WARN_ON(1);
2024                 return false; /* don't expect to be here */
2025         }
2026
2027         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2028                 return false;
2029
2030         return true;
2031 }
2032
2033 static bool
2034 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2035 {
2036         unsigned int secFlags;
2037
2038         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2039                 secFlags = vol->secFlg;
2040         else
2041                 secFlags = global_secflags | vol->secFlg;
2042
2043         switch (server->secType) {
2044         case LANMAN:
2045                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2046                         return false;
2047                 break;
2048         case NTLMv2:
2049                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2050                         return false;
2051                 break;
2052         case NTLM:
2053                 if (!(secFlags & CIFSSEC_MAY_NTLM))
2054                         return false;
2055                 break;
2056         case Kerberos:
2057                 if (!(secFlags & CIFSSEC_MAY_KRB5))
2058                         return false;
2059                 break;
2060         case RawNTLMSSP:
2061                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2062                         return false;
2063                 break;
2064         default:
2065                 /* shouldn't happen */
2066                 return false;
2067         }
2068
2069         /* now check if signing mode is acceptable */
2070         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2071             (server->sec_mode & SECMODE_SIGN_REQUIRED))
2072                         return false;
2073         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2074                  (server->sec_mode &
2075                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2076                         return false;
2077
2078         return true;
2079 }
2080
2081 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2082                          struct smb_vol *vol)
2083 {
2084         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2085                 return 0;
2086
2087         if (!match_address(server, addr,
2088                            (struct sockaddr *)&vol->srcaddr))
2089                 return 0;
2090
2091         if (!match_port(server, addr))
2092                 return 0;
2093
2094         if (!match_security(server, vol))
2095                 return 0;
2096
2097         return 1;
2098 }
2099
2100 static struct TCP_Server_Info *
2101 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
2102 {
2103         struct TCP_Server_Info *server;
2104
2105         spin_lock(&cifs_tcp_ses_lock);
2106         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2107                 if (!match_server(server, addr, vol))
2108                         continue;
2109
2110                 ++server->srv_count;
2111                 spin_unlock(&cifs_tcp_ses_lock);
2112                 cFYI(1, "Existing tcp session with server found");
2113                 return server;
2114         }
2115         spin_unlock(&cifs_tcp_ses_lock);
2116         return NULL;
2117 }
2118
2119 static void
2120 cifs_put_tcp_session(struct TCP_Server_Info *server)
2121 {
2122         struct task_struct *task;
2123
2124         spin_lock(&cifs_tcp_ses_lock);
2125         if (--server->srv_count > 0) {
2126                 spin_unlock(&cifs_tcp_ses_lock);
2127                 return;
2128         }
2129
2130         put_net(cifs_net_ns(server));
2131
2132         list_del_init(&server->tcp_ses_list);
2133         spin_unlock(&cifs_tcp_ses_lock);
2134
2135         cancel_delayed_work_sync(&server->echo);
2136
2137         spin_lock(&GlobalMid_Lock);
2138         server->tcpStatus = CifsExiting;
2139         spin_unlock(&GlobalMid_Lock);
2140
2141         cifs_crypto_shash_release(server);
2142         cifs_fscache_release_client_cookie(server);
2143
2144         kfree(server->session_key.response);
2145         server->session_key.response = NULL;
2146         server->session_key.len = 0;
2147
2148         task = xchg(&server->tsk, NULL);
2149         if (task)
2150                 force_sig(SIGKILL, task);
2151 }
2152
2153 static struct TCP_Server_Info *
2154 cifs_get_tcp_session(struct smb_vol *volume_info)
2155 {
2156         struct TCP_Server_Info *tcp_ses = NULL;
2157         struct sockaddr_storage addr;
2158         struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2159         struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2160         int rc;
2161
2162         memset(&addr, 0, sizeof(struct sockaddr_storage));
2163
2164         cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
2165
2166         if (volume_info->UNCip && volume_info->UNC) {
2167                 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2168                                         volume_info->UNCip,
2169                                         strlen(volume_info->UNCip),
2170                                         volume_info->port);
2171                 if (!rc) {
2172                         /* we failed translating address */
2173                         rc = -EINVAL;
2174                         goto out_err;
2175                 }
2176         } else if (volume_info->UNCip) {
2177                 /* BB using ip addr as tcp_ses name to connect to the
2178                    DFS root below */
2179                 cERROR(1, "Connecting to DFS root not implemented yet");
2180                 rc = -EINVAL;
2181                 goto out_err;
2182         } else /* which tcp_sess DFS root would we conect to */ {
2183                 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2184                         "unc=//192.168.1.100/public) specified");
2185                 rc = -EINVAL;
2186                 goto out_err;
2187         }
2188
2189         /* see if we already have a matching tcp_ses */
2190         tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
2191         if (tcp_ses)
2192                 return tcp_ses;
2193
2194         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2195         if (!tcp_ses) {
2196                 rc = -ENOMEM;
2197                 goto out_err;
2198         }
2199
2200         rc = cifs_crypto_shash_allocate(tcp_ses);
2201         if (rc) {
2202                 cERROR(1, "could not setup hash structures rc %d", rc);
2203                 goto out_err;
2204         }
2205
2206         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2207         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2208         if (IS_ERR(tcp_ses->hostname)) {
2209                 rc = PTR_ERR(tcp_ses->hostname);
2210                 goto out_err_crypto_release;
2211         }
2212
2213         tcp_ses->noblocksnd = volume_info->noblocksnd;
2214         tcp_ses->noautotune = volume_info->noautotune;
2215         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2216         tcp_ses->in_flight = 0;
2217         tcp_ses->credits = 1;
2218         init_waitqueue_head(&tcp_ses->response_q);
2219         init_waitqueue_head(&tcp_ses->request_q);
2220         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2221         mutex_init(&tcp_ses->srv_mutex);
2222         memcpy(tcp_ses->workstation_RFC1001_name,
2223                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2224         memcpy(tcp_ses->server_RFC1001_name,
2225                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2226         tcp_ses->session_estab = false;
2227         tcp_ses->sequence_number = 0;
2228         tcp_ses->lstrp = jiffies;
2229         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2230         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2231         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2232
2233         /*
2234          * at this point we are the only ones with the pointer
2235          * to the struct since the kernel thread not created yet
2236          * no need to spinlock this init of tcpStatus or srv_count
2237          */
2238         tcp_ses->tcpStatus = CifsNew;
2239         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2240                sizeof(tcp_ses->srcaddr));
2241         ++tcp_ses->srv_count;
2242
2243         if (addr.ss_family == AF_INET6) {
2244                 cFYI(1, "attempting ipv6 connect");
2245                 /* BB should we allow ipv6 on port 139? */
2246                 /* other OS never observed in Wild doing 139 with v6 */
2247                 memcpy(&tcp_ses->dstaddr, sin_server6,
2248                        sizeof(struct sockaddr_in6));
2249         } else
2250                 memcpy(&tcp_ses->dstaddr, sin_server,
2251                        sizeof(struct sockaddr_in));
2252
2253         rc = ip_connect(tcp_ses);
2254         if (rc < 0) {
2255                 cERROR(1, "Error connecting to socket. Aborting operation");
2256                 goto out_err_crypto_release;
2257         }
2258
2259         /*
2260          * since we're in a cifs function already, we know that
2261          * this will succeed. No need for try_module_get().
2262          */
2263         __module_get(THIS_MODULE);
2264         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2265                                   tcp_ses, "cifsd");
2266         if (IS_ERR(tcp_ses->tsk)) {
2267                 rc = PTR_ERR(tcp_ses->tsk);
2268                 cERROR(1, "error %d create cifsd thread", rc);
2269                 module_put(THIS_MODULE);
2270                 goto out_err_crypto_release;
2271         }
2272         tcp_ses->tcpStatus = CifsNeedNegotiate;
2273
2274         /* thread spawned, put it on the list */
2275         spin_lock(&cifs_tcp_ses_lock);
2276         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2277         spin_unlock(&cifs_tcp_ses_lock);
2278
2279         cifs_fscache_get_client_cookie(tcp_ses);
2280
2281         /* queue echo request delayed work */
2282         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2283
2284         return tcp_ses;
2285
2286 out_err_crypto_release:
2287         cifs_crypto_shash_release(tcp_ses);
2288
2289         put_net(cifs_net_ns(tcp_ses));
2290
2291 out_err:
2292         if (tcp_ses) {
2293                 if (!IS_ERR(tcp_ses->hostname))
2294                         kfree(tcp_ses->hostname);
2295                 if (tcp_ses->ssocket)
2296                         sock_release(tcp_ses->ssocket);
2297                 kfree(tcp_ses);
2298         }
2299         return ERR_PTR(rc);
2300 }
2301
2302 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2303 {
2304         switch (ses->server->secType) {
2305         case Kerberos:
2306                 if (vol->cred_uid != ses->cred_uid)
2307                         return 0;
2308                 break;
2309         default:
2310                 /* NULL username means anonymous session */
2311                 if (ses->user_name == NULL) {
2312                         if (!vol->nullauth)
2313                                 return 0;
2314                         break;
2315                 }
2316
2317                 /* anything else takes username/password */
2318                 if (strncmp(ses->user_name,
2319                             vol->username ? vol->username : "",
2320                             MAX_USERNAME_SIZE))
2321                         return 0;
2322                 if (strlen(vol->username) != 0 &&
2323                     ses->password != NULL &&
2324                     strncmp(ses->password,
2325                             vol->password ? vol->password : "",
2326                             MAX_PASSWORD_SIZE))
2327                         return 0;
2328         }
2329         return 1;
2330 }
2331
2332 static struct cifs_ses *
2333 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2334 {
2335         struct cifs_ses *ses;
2336
2337         spin_lock(&cifs_tcp_ses_lock);
2338         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2339                 if (!match_session(ses, vol))
2340                         continue;
2341                 ++ses->ses_count;
2342                 spin_unlock(&cifs_tcp_ses_lock);
2343                 return ses;
2344         }
2345         spin_unlock(&cifs_tcp_ses_lock);
2346         return NULL;
2347 }
2348
2349 static void
2350 cifs_put_smb_ses(struct cifs_ses *ses)
2351 {
2352         int xid;
2353         struct TCP_Server_Info *server = ses->server;
2354
2355         cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
2356         spin_lock(&cifs_tcp_ses_lock);
2357         if (--ses->ses_count > 0) {
2358                 spin_unlock(&cifs_tcp_ses_lock);
2359                 return;
2360         }
2361
2362         list_del_init(&ses->smb_ses_list);
2363         spin_unlock(&cifs_tcp_ses_lock);
2364
2365         if (ses->status == CifsGood) {
2366                 xid = GetXid();
2367                 CIFSSMBLogoff(xid, ses);
2368                 _FreeXid(xid);
2369         }
2370         sesInfoFree(ses);
2371         cifs_put_tcp_session(server);
2372 }
2373
2374 #ifdef CONFIG_KEYS
2375
2376 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2377 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2378
2379 /* Populate username and pw fields from keyring if possible */
2380 static int
2381 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2382 {
2383         int rc = 0;
2384         char *desc, *delim, *payload;
2385         ssize_t len;
2386         struct key *key;
2387         struct TCP_Server_Info *server = ses->server;
2388         struct sockaddr_in *sa;
2389         struct sockaddr_in6 *sa6;
2390         struct user_key_payload *upayload;
2391
2392         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2393         if (!desc)
2394                 return -ENOMEM;
2395
2396         /* try to find an address key first */
2397         switch (server->dstaddr.ss_family) {
2398         case AF_INET:
2399                 sa = (struct sockaddr_in *)&server->dstaddr;
2400                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2401                 break;
2402         case AF_INET6:
2403                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2404                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2405                 break;
2406         default:
2407                 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2408                 rc = -EINVAL;
2409                 goto out_err;
2410         }
2411
2412         cFYI(1, "%s: desc=%s", __func__, desc);
2413         key = request_key(&key_type_logon, desc, "");
2414         if (IS_ERR(key)) {
2415                 if (!ses->domainName) {
2416                         cFYI(1, "domainName is NULL");
2417                         rc = PTR_ERR(key);
2418                         goto out_err;
2419                 }
2420
2421                 /* didn't work, try to find a domain key */
2422                 sprintf(desc, "cifs:d:%s", ses->domainName);
2423                 cFYI(1, "%s: desc=%s", __func__, desc);
2424                 key = request_key(&key_type_logon, desc, "");
2425                 if (IS_ERR(key)) {
2426                         rc = PTR_ERR(key);
2427                         goto out_err;
2428                 }
2429         }
2430
2431         down_read(&key->sem);
2432         upayload = key->payload.data;
2433         if (IS_ERR_OR_NULL(upayload)) {
2434                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2435                 goto out_key_put;
2436         }
2437
2438         /* find first : in payload */
2439         payload = (char *)upayload->data;
2440         delim = strnchr(payload, upayload->datalen, ':');
2441         cFYI(1, "payload=%s", payload);
2442         if (!delim) {
2443                 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2444                                 upayload->datalen);
2445                 rc = -EINVAL;
2446                 goto out_key_put;
2447         }
2448
2449         len = delim - payload;
2450         if (len > MAX_USERNAME_SIZE || len <= 0) {
2451                 cFYI(1, "Bad value from username search (len=%zd)", len);
2452                 rc = -EINVAL;
2453                 goto out_key_put;
2454         }
2455
2456         vol->username = kstrndup(payload, len, GFP_KERNEL);
2457         if (!vol->username) {
2458                 cFYI(1, "Unable to allocate %zd bytes for username", len);
2459                 rc = -ENOMEM;
2460                 goto out_key_put;
2461         }
2462         cFYI(1, "%s: username=%s", __func__, vol->username);
2463
2464         len = key->datalen - (len + 1);
2465         if (len > MAX_PASSWORD_SIZE || len <= 0) {
2466                 cFYI(1, "Bad len for password search (len=%zd)", len);
2467                 rc = -EINVAL;
2468                 kfree(vol->username);
2469                 vol->username = NULL;
2470                 goto out_key_put;
2471         }
2472
2473         ++delim;
2474         vol->password = kstrndup(delim, len, GFP_KERNEL);
2475         if (!vol->password) {
2476                 cFYI(1, "Unable to allocate %zd bytes for password", len);
2477                 rc = -ENOMEM;
2478                 kfree(vol->username);
2479                 vol->username = NULL;
2480                 goto out_key_put;
2481         }
2482
2483 out_key_put:
2484         up_read(&key->sem);
2485         key_put(key);
2486 out_err:
2487         kfree(desc);
2488         cFYI(1, "%s: returning %d", __func__, rc);
2489         return rc;
2490 }
2491 #else /* ! CONFIG_KEYS */
2492 static inline int
2493 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2494                    struct cifs_ses *ses __attribute__((unused)))
2495 {
2496         return -ENOSYS;
2497 }
2498 #endif /* CONFIG_KEYS */
2499
2500 static bool warned_on_ntlm;  /* globals init to false automatically */
2501
2502 static struct cifs_ses *
2503 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2504 {
2505         int rc = -ENOMEM, xid;
2506         struct cifs_ses *ses;
2507         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2508         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2509
2510         xid = GetXid();
2511
2512         ses = cifs_find_smb_ses(server, volume_info);
2513         if (ses) {
2514                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2515
2516                 mutex_lock(&ses->session_mutex);
2517                 rc = cifs_negotiate_protocol(xid, ses);
2518                 if (rc) {
2519                         mutex_unlock(&ses->session_mutex);
2520                         /* problem -- put our ses reference */
2521                         cifs_put_smb_ses(ses);
2522                         FreeXid(xid);
2523                         return ERR_PTR(rc);
2524                 }
2525                 if (ses->need_reconnect) {
2526                         cFYI(1, "Session needs reconnect");
2527                         rc = cifs_setup_session(xid, ses,
2528                                                 volume_info->local_nls);
2529                         if (rc) {
2530                                 mutex_unlock(&ses->session_mutex);
2531                                 /* problem -- put our reference */
2532                                 cifs_put_smb_ses(ses);
2533                                 FreeXid(xid);
2534                                 return ERR_PTR(rc);
2535                         }
2536                 }
2537                 mutex_unlock(&ses->session_mutex);
2538
2539                 /* existing SMB ses has a server reference already */
2540                 cifs_put_tcp_session(server);
2541                 FreeXid(xid);
2542                 return ses;
2543         }
2544
2545         cFYI(1, "Existing smb sess not found");
2546         ses = sesInfoAlloc();
2547         if (ses == NULL)
2548                 goto get_ses_fail;
2549
2550         /* new SMB session uses our server ref */
2551         ses->server = server;
2552         if (server->dstaddr.ss_family == AF_INET6)
2553                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2554         else
2555                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2556
2557         if (volume_info->username) {
2558                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2559                 if (!ses->user_name)
2560                         goto get_ses_fail;
2561         }
2562
2563         /* volume_info->password freed at unmount */
2564         if (volume_info->password) {
2565                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2566                 if (!ses->password)
2567                         goto get_ses_fail;
2568         }
2569         if (volume_info->domainname) {
2570                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2571                 if (!ses->domainName)
2572                         goto get_ses_fail;
2573         }
2574         ses->cred_uid = volume_info->cred_uid;
2575         ses->linux_uid = volume_info->linux_uid;
2576
2577         /* ntlmv2 is much stronger than ntlm security, and has been broadly
2578         supported for many years, time to update default security mechanism */
2579         if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2580                 warned_on_ntlm = true;
2581                 cERROR(1, "default security mechanism requested.  The default "
2582                         "security mechanism will be upgraded from ntlm to "
2583                         "ntlmv2 in kernel release 3.3");
2584         }
2585         ses->overrideSecFlg = volume_info->secFlg;
2586
2587         mutex_lock(&ses->session_mutex);
2588         rc = cifs_negotiate_protocol(xid, ses);
2589         if (!rc)
2590                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2591         mutex_unlock(&ses->session_mutex);
2592         if (rc)
2593                 goto get_ses_fail;
2594
2595         /* success, put it on the list */
2596         spin_lock(&cifs_tcp_ses_lock);
2597         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2598         spin_unlock(&cifs_tcp_ses_lock);
2599
2600         FreeXid(xid);
2601         return ses;
2602
2603 get_ses_fail:
2604         sesInfoFree(ses);
2605         FreeXid(xid);
2606         return ERR_PTR(rc);
2607 }
2608
2609 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2610 {
2611         if (tcon->tidStatus == CifsExiting)
2612                 return 0;
2613         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2614                 return 0;
2615         return 1;
2616 }
2617
2618 static struct cifs_tcon *
2619 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2620 {
2621         struct list_head *tmp;
2622         struct cifs_tcon *tcon;
2623
2624         spin_lock(&cifs_tcp_ses_lock);
2625         list_for_each(tmp, &ses->tcon_list) {
2626                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2627                 if (!match_tcon(tcon, unc))
2628                         continue;
2629                 ++tcon->tc_count;
2630                 spin_unlock(&cifs_tcp_ses_lock);
2631                 return tcon;
2632         }
2633         spin_unlock(&cifs_tcp_ses_lock);
2634         return NULL;
2635 }
2636
2637 static void
2638 cifs_put_tcon(struct cifs_tcon *tcon)
2639 {
2640         int xid;
2641         struct cifs_ses *ses = tcon->ses;
2642
2643         cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2644         spin_lock(&cifs_tcp_ses_lock);
2645         if (--tcon->tc_count > 0) {
2646                 spin_unlock(&cifs_tcp_ses_lock);
2647                 return;
2648         }
2649
2650         list_del_init(&tcon->tcon_list);
2651         spin_unlock(&cifs_tcp_ses_lock);
2652
2653         xid = GetXid();
2654         CIFSSMBTDis(xid, tcon);
2655         _FreeXid(xid);
2656
2657         cifs_fscache_release_super_cookie(tcon);
2658         tconInfoFree(tcon);
2659         cifs_put_smb_ses(ses);
2660 }
2661
2662 static struct cifs_tcon *
2663 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2664 {
2665         int rc, xid;
2666         struct cifs_tcon *tcon;
2667
2668         tcon = cifs_find_tcon(ses, volume_info->UNC);
2669         if (tcon) {
2670                 cFYI(1, "Found match on UNC path");
2671                 /* existing tcon already has a reference */
2672                 cifs_put_smb_ses(ses);
2673                 if (tcon->seal != volume_info->seal)
2674                         cERROR(1, "transport encryption setting "
2675                                    "conflicts with existing tid");
2676                 return tcon;
2677         }
2678
2679         tcon = tconInfoAlloc();
2680         if (tcon == NULL) {
2681                 rc = -ENOMEM;
2682                 goto out_fail;
2683         }
2684
2685         tcon->ses = ses;
2686         if (volume_info->password) {
2687                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2688                 if (!tcon->password) {
2689                         rc = -ENOMEM;
2690                         goto out_fail;
2691                 }
2692         }
2693
2694         if (strchr(volume_info->UNC + 3, '\\') == NULL
2695             && strchr(volume_info->UNC + 3, '/') == NULL) {
2696                 cERROR(1, "Missing share name");
2697                 rc = -ENODEV;
2698                 goto out_fail;
2699         }
2700
2701         /* BB Do we need to wrap session_mutex around
2702          * this TCon call and Unix SetFS as
2703          * we do on SessSetup and reconnect? */
2704         xid = GetXid();
2705         rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2706         FreeXid(xid);
2707         cFYI(1, "CIFS Tcon rc = %d", rc);
2708         if (rc)
2709                 goto out_fail;
2710
2711         if (volume_info->nodfs) {
2712                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2713                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2714         }
2715         tcon->seal = volume_info->seal;
2716         /* we can have only one retry value for a connection
2717            to a share so for resources mounted more than once
2718            to the same server share the last value passed in
2719            for the retry flag is used */
2720         tcon->retry = volume_info->retry;
2721         tcon->nocase = volume_info->nocase;
2722         tcon->local_lease = volume_info->local_lease;
2723
2724         spin_lock(&cifs_tcp_ses_lock);
2725         list_add(&tcon->tcon_list, &ses->tcon_list);
2726         spin_unlock(&cifs_tcp_ses_lock);
2727
2728         cifs_fscache_get_super_cookie(tcon);
2729
2730         return tcon;
2731
2732 out_fail:
2733         tconInfoFree(tcon);
2734         return ERR_PTR(rc);
2735 }
2736
2737 void
2738 cifs_put_tlink(struct tcon_link *tlink)
2739 {
2740         if (!tlink || IS_ERR(tlink))
2741                 return;
2742
2743         if (!atomic_dec_and_test(&tlink->tl_count) ||
2744             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2745                 tlink->tl_time = jiffies;
2746                 return;
2747         }
2748
2749         if (!IS_ERR(tlink_tcon(tlink)))
2750                 cifs_put_tcon(tlink_tcon(tlink));
2751         kfree(tlink);
2752         return;
2753 }
2754
2755 static inline struct tcon_link *
2756 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2757 {
2758         return cifs_sb->master_tlink;
2759 }
2760
2761 static int
2762 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2763 {
2764         struct cifs_sb_info *old = CIFS_SB(sb);
2765         struct cifs_sb_info *new = mnt_data->cifs_sb;
2766
2767         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2768                 return 0;
2769
2770         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2771             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2772                 return 0;
2773
2774         /*
2775          * We want to share sb only if we don't specify an r/wsize or
2776          * specified r/wsize is greater than or equal to existing one.
2777          */
2778         if (new->wsize && new->wsize < old->wsize)
2779                 return 0;
2780
2781         if (new->rsize && new->rsize < old->rsize)
2782                 return 0;
2783
2784         if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2785                 return 0;
2786
2787         if (old->mnt_file_mode != new->mnt_file_mode ||
2788             old->mnt_dir_mode != new->mnt_dir_mode)
2789                 return 0;
2790
2791         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2792                 return 0;
2793
2794         if (old->actimeo != new->actimeo)
2795                 return 0;
2796
2797         return 1;
2798 }
2799
2800 int
2801 cifs_match_super(struct super_block *sb, void *data)
2802 {
2803         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2804         struct smb_vol *volume_info;
2805         struct cifs_sb_info *cifs_sb;
2806         struct TCP_Server_Info *tcp_srv;
2807         struct cifs_ses *ses;
2808         struct cifs_tcon *tcon;
2809         struct tcon_link *tlink;
2810         struct sockaddr_storage addr;
2811         int rc = 0;
2812
2813         memset(&addr, 0, sizeof(struct sockaddr_storage));
2814
2815         spin_lock(&cifs_tcp_ses_lock);
2816         cifs_sb = CIFS_SB(sb);
2817         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2818         if (IS_ERR(tlink)) {
2819                 spin_unlock(&cifs_tcp_ses_lock);
2820                 return rc;
2821         }
2822         tcon = tlink_tcon(tlink);
2823         ses = tcon->ses;
2824         tcp_srv = ses->server;
2825
2826         volume_info = mnt_data->vol;
2827
2828         if (!volume_info->UNCip || !volume_info->UNC)
2829                 goto out;
2830
2831         rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2832                                 volume_info->UNCip,
2833                                 strlen(volume_info->UNCip),
2834                                 volume_info->port);
2835         if (!rc)
2836                 goto out;
2837
2838         if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2839             !match_session(ses, volume_info) ||
2840             !match_tcon(tcon, volume_info->UNC)) {
2841                 rc = 0;
2842                 goto out;
2843         }
2844
2845         rc = compare_mount_options(sb, mnt_data);
2846 out:
2847         spin_unlock(&cifs_tcp_ses_lock);
2848         cifs_put_tlink(tlink);
2849         return rc;
2850 }
2851
2852 int
2853 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2854              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2855              struct dfs_info3_param **preferrals, int remap)
2856 {
2857         char *temp_unc;
2858         int rc = 0;
2859
2860         *pnum_referrals = 0;
2861         *preferrals = NULL;
2862
2863         if (pSesInfo->ipc_tid == 0) {
2864                 temp_unc = kmalloc(2 /* for slashes */ +
2865                         strnlen(pSesInfo->serverName,
2866                                 SERVER_NAME_LEN_WITH_NULL * 2)
2867                                  + 1 + 4 /* slash IPC$ */  + 2,
2868                                 GFP_KERNEL);
2869                 if (temp_unc == NULL)
2870                         return -ENOMEM;
2871                 temp_unc[0] = '\\';
2872                 temp_unc[1] = '\\';
2873                 strcpy(temp_unc + 2, pSesInfo->serverName);
2874                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2875                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2876                 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2877                 kfree(temp_unc);
2878         }
2879         if (rc == 0)
2880                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2881                                      pnum_referrals, nls_codepage, remap);
2882         /* BB map targetUNCs to dfs_info3 structures, here or
2883                 in CIFSGetDFSRefer BB */
2884
2885         return rc;
2886 }
2887
2888 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2889 static struct lock_class_key cifs_key[2];
2890 static struct lock_class_key cifs_slock_key[2];
2891
2892 static inline void
2893 cifs_reclassify_socket4(struct socket *sock)
2894 {
2895         struct sock *sk = sock->sk;
2896         BUG_ON(sock_owned_by_user(sk));
2897         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2898                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2899 }
2900
2901 static inline void
2902 cifs_reclassify_socket6(struct socket *sock)
2903 {
2904         struct sock *sk = sock->sk;
2905         BUG_ON(sock_owned_by_user(sk));
2906         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2907                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2908 }
2909 #else
2910 static inline void
2911 cifs_reclassify_socket4(struct socket *sock)
2912 {
2913 }
2914
2915 static inline void
2916 cifs_reclassify_socket6(struct socket *sock)
2917 {
2918 }
2919 #endif
2920
2921 /* See RFC1001 section 14 on representation of Netbios names */
2922 static void rfc1002mangle(char *target, char *source, unsigned int length)
2923 {
2924         unsigned int i, j;
2925
2926         for (i = 0, j = 0; i < (length); i++) {
2927                 /* mask a nibble at a time and encode */
2928                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2929                 target[j+1] = 'A' + (0x0F & source[i]);
2930                 j += 2;
2931         }
2932
2933 }
2934
2935 static int
2936 bind_socket(struct TCP_Server_Info *server)
2937 {
2938         int rc = 0;
2939         if (server->srcaddr.ss_family != AF_UNSPEC) {
2940                 /* Bind to the specified local IP address */
2941                 struct socket *socket = server->ssocket;
2942                 rc = socket->ops->bind(socket,
2943                                        (struct sockaddr *) &server->srcaddr,
2944                                        sizeof(server->srcaddr));
2945                 if (rc < 0) {
2946                         struct sockaddr_in *saddr4;
2947                         struct sockaddr_in6 *saddr6;
2948                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2949                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2950                         if (saddr6->sin6_family == AF_INET6)
2951                                 cERROR(1, "cifs: "
2952                                        "Failed to bind to: %pI6c, error: %d\n",
2953                                        &saddr6->sin6_addr, rc);
2954                         else
2955                                 cERROR(1, "cifs: "
2956                                        "Failed to bind to: %pI4, error: %d\n",
2957                                        &saddr4->sin_addr.s_addr, rc);
2958                 }
2959         }
2960         return rc;
2961 }
2962
2963 static int
2964 ip_rfc1001_connect(struct TCP_Server_Info *server)
2965 {
2966         int rc = 0;
2967         /*
2968          * some servers require RFC1001 sessinit before sending
2969          * negprot - BB check reconnection in case where second
2970          * sessinit is sent but no second negprot
2971          */
2972         struct rfc1002_session_packet *ses_init_buf;
2973         struct smb_hdr *smb_buf;
2974         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2975                                GFP_KERNEL);
2976         if (ses_init_buf) {
2977                 ses_init_buf->trailer.session_req.called_len = 32;
2978
2979                 if (server->server_RFC1001_name &&
2980                     server->server_RFC1001_name[0] != 0)
2981                         rfc1002mangle(ses_init_buf->trailer.
2982                                       session_req.called_name,
2983                                       server->server_RFC1001_name,
2984                                       RFC1001_NAME_LEN_WITH_NULL);
2985                 else
2986                         rfc1002mangle(ses_init_buf->trailer.
2987                                       session_req.called_name,
2988                                       DEFAULT_CIFS_CALLED_NAME,
2989                                       RFC1001_NAME_LEN_WITH_NULL);
2990
2991                 ses_init_buf->trailer.session_req.calling_len = 32;
2992
2993                 /*
2994                  * calling name ends in null (byte 16) from old smb
2995                  * convention.
2996                  */
2997                 if (server->workstation_RFC1001_name &&
2998                     server->workstation_RFC1001_name[0] != 0)
2999                         rfc1002mangle(ses_init_buf->trailer.
3000                                       session_req.calling_name,
3001                                       server->workstation_RFC1001_name,
3002                                       RFC1001_NAME_LEN_WITH_NULL);
3003                 else
3004                         rfc1002mangle(ses_init_buf->trailer.
3005                                       session_req.calling_name,
3006                                       "LINUX_CIFS_CLNT",
3007                                       RFC1001_NAME_LEN_WITH_NULL);
3008
3009                 ses_init_buf->trailer.session_req.scope1 = 0;
3010                 ses_init_buf->trailer.session_req.scope2 = 0;
3011                 smb_buf = (struct smb_hdr *)ses_init_buf;
3012
3013                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3014                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3015                 rc = smb_send(server, smb_buf, 0x44);
3016                 kfree(ses_init_buf);
3017                 /*
3018                  * RFC1001 layer in at least one server
3019                  * requires very short break before negprot
3020                  * presumably because not expecting negprot
3021                  * to follow so fast.  This is a simple
3022                  * solution that works without
3023                  * complicating the code and causes no
3024                  * significant slowing down on mount
3025                  * for everyone else
3026                  */
3027                 usleep_range(1000, 2000);
3028         }
3029         /*
3030          * else the negprot may still work without this
3031          * even though malloc failed
3032          */
3033
3034         return rc;
3035 }
3036
3037 static int
3038 generic_ip_connect(struct TCP_Server_Info *server)
3039 {
3040         int rc = 0;
3041         __be16 sport;
3042         int slen, sfamily;
3043         struct socket *socket = server->ssocket;
3044         struct sockaddr *saddr;
3045
3046         saddr = (struct sockaddr *) &server->dstaddr;
3047
3048         if (server->dstaddr.ss_family == AF_INET6) {
3049                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3050                 slen = sizeof(struct sockaddr_in6);
3051                 sfamily = AF_INET6;
3052         } else {
3053                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3054                 slen = sizeof(struct sockaddr_in);
3055                 sfamily = AF_INET;
3056         }
3057
3058         if (socket == NULL) {
3059                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3060                                    IPPROTO_TCP, &socket, 1);
3061                 if (rc < 0) {
3062                         cERROR(1, "Error %d creating socket", rc);
3063                         server->ssocket = NULL;
3064                         return rc;
3065                 }
3066
3067                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3068                 cFYI(1, "Socket created");
3069                 server->ssocket = socket;
3070                 socket->sk->sk_allocation = GFP_NOFS;
3071                 if (sfamily == AF_INET6)
3072                         cifs_reclassify_socket6(socket);
3073                 else
3074                         cifs_reclassify_socket4(socket);
3075         }
3076
3077         rc = bind_socket(server);
3078         if (rc < 0)
3079                 return rc;
3080
3081         /*
3082          * Eventually check for other socket options to change from
3083          * the default. sock_setsockopt not used because it expects
3084          * user space buffer
3085          */
3086         socket->sk->sk_rcvtimeo = 7 * HZ;
3087         socket->sk->sk_sndtimeo = 5 * HZ;
3088
3089         /* make the bufsizes depend on wsize/rsize and max requests */
3090         if (server->noautotune) {
3091                 if (socket->sk->sk_sndbuf < (200 * 1024))
3092                         socket->sk->sk_sndbuf = 200 * 1024;
3093                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3094                         socket->sk->sk_rcvbuf = 140 * 1024;
3095         }
3096
3097         if (server->tcp_nodelay) {
3098                 int val = 1;
3099                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3100                                 (char *)&val, sizeof(val));
3101                 if (rc)
3102                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3103         }
3104
3105          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3106                  socket->sk->sk_sndbuf,
3107                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3108
3109         rc = socket->ops->connect(socket, saddr, slen, 0);
3110         if (rc < 0) {
3111                 cFYI(1, "Error %d connecting to server", rc);
3112                 sock_release(socket);
3113                 server->ssocket = NULL;
3114                 return rc;
3115         }
3116
3117         if (sport == htons(RFC1001_PORT))
3118                 rc = ip_rfc1001_connect(server);
3119
3120         return rc;
3121 }
3122
3123 static int
3124 ip_connect(struct TCP_Server_Info *server)
3125 {
3126         __be16 *sport;
3127         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3128         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3129
3130         if (server->dstaddr.ss_family == AF_INET6)
3131                 sport = &addr6->sin6_port;
3132         else
3133                 sport = &addr->sin_port;
3134
3135         if (*sport == 0) {
3136                 int rc;
3137
3138                 /* try with 445 port at first */
3139                 *sport = htons(CIFS_PORT);
3140
3141                 rc = generic_ip_connect(server);
3142                 if (rc >= 0)
3143                         return rc;
3144
3145                 /* if it failed, try with 139 port */
3146                 *sport = htons(RFC1001_PORT);
3147         }
3148
3149         return generic_ip_connect(server);
3150 }
3151
3152 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3153                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3154 {
3155         /* if we are reconnecting then should we check to see if
3156          * any requested capabilities changed locally e.g. via
3157          * remount but we can not do much about it here
3158          * if they have (even if we could detect it by the following)
3159          * Perhaps we could add a backpointer to array of sb from tcon
3160          * or if we change to make all sb to same share the same
3161          * sb as NFS - then we only have one backpointer to sb.
3162          * What if we wanted to mount the server share twice once with
3163          * and once without posixacls or posix paths? */
3164         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3165
3166         if (vol_info && vol_info->no_linux_ext) {
3167                 tcon->fsUnixInfo.Capability = 0;
3168                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3169                 cFYI(1, "Linux protocol extensions disabled");
3170                 return;
3171         } else if (vol_info)
3172                 tcon->unix_ext = 1; /* Unix Extensions supported */
3173
3174         if (tcon->unix_ext == 0) {
3175                 cFYI(1, "Unix extensions disabled so not set on reconnect");
3176                 return;
3177         }
3178
3179         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3180                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3181                 cFYI(1, "unix caps which server supports %lld", cap);
3182                 /* check for reconnect case in which we do not
3183                    want to change the mount behavior if we can avoid it */
3184                 if (vol_info == NULL) {
3185                         /* turn off POSIX ACL and PATHNAMES if not set
3186                            originally at mount time */
3187                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3188                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3189                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3190                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3191                                         cERROR(1, "POSIXPATH support change");
3192                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3193                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3194                                 cERROR(1, "possible reconnect error");
3195                                 cERROR(1, "server disabled POSIX path support");
3196                         }
3197                 }
3198
3199                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3200                         cERROR(1, "per-share encryption not supported yet");
3201
3202                 cap &= CIFS_UNIX_CAP_MASK;
3203                 if (vol_info && vol_info->no_psx_acl)
3204                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3205                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3206                         cFYI(1, "negotiated posix acl support");
3207                         if (cifs_sb)
3208                                 cifs_sb->mnt_cifs_flags |=
3209                                         CIFS_MOUNT_POSIXACL;
3210                 }
3211
3212                 if (vol_info && vol_info->posix_paths == 0)
3213                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3214                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3215                         cFYI(1, "negotiate posix pathnames");
3216                         if (cifs_sb)
3217                                 cifs_sb->mnt_cifs_flags |=
3218                                         CIFS_MOUNT_POSIX_PATHS;
3219                 }
3220
3221                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3222 #ifdef CONFIG_CIFS_DEBUG2
3223                 if (cap & CIFS_UNIX_FCNTL_CAP)
3224                         cFYI(1, "FCNTL cap");
3225                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3226                         cFYI(1, "EXTATTR cap");
3227                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3228                         cFYI(1, "POSIX path cap");
3229                 if (cap & CIFS_UNIX_XATTR_CAP)
3230                         cFYI(1, "XATTR cap");
3231                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3232                         cFYI(1, "POSIX ACL cap");
3233                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3234                         cFYI(1, "very large read cap");
3235                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3236                         cFYI(1, "very large write cap");
3237                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3238                         cFYI(1, "transport encryption cap");
3239                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3240                         cFYI(1, "mandatory transport encryption cap");
3241 #endif /* CIFS_DEBUG2 */
3242                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3243                         if (vol_info == NULL) {
3244                                 cFYI(1, "resetting capabilities failed");
3245                         } else
3246                                 cERROR(1, "Negotiating Unix capabilities "
3247                                            "with the server failed.  Consider "
3248                                            "mounting with the Unix Extensions\n"
3249                                            "disabled, if problems are found, "
3250                                            "by specifying the nounix mount "
3251                                            "option.");
3252
3253                 }
3254         }
3255 }
3256
3257 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3258                         struct cifs_sb_info *cifs_sb)
3259 {
3260         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3261
3262         spin_lock_init(&cifs_sb->tlink_tree_lock);
3263         cifs_sb->tlink_tree = RB_ROOT;
3264
3265         /*
3266          * Temporarily set r/wsize for matching superblock. If we end up using
3267          * new sb then client will later negotiate it downward if needed.
3268          */
3269         cifs_sb->rsize = pvolume_info->rsize;
3270         cifs_sb->wsize = pvolume_info->wsize;
3271
3272         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3273         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3274         if (pvolume_info->backupuid_specified)
3275                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3276         if (pvolume_info->backupgid_specified)
3277                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3278         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3279         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3280         cFYI(1, "file mode: 0x%hx  dir mode: 0x%hx",
3281                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3282
3283         cifs_sb->actimeo = pvolume_info->actimeo;
3284         cifs_sb->local_nls = pvolume_info->local_nls;
3285
3286         if (pvolume_info->noperm)
3287                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3288         if (pvolume_info->setuids)
3289                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3290         if (pvolume_info->server_ino)
3291                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3292         if (pvolume_info->remap)
3293                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3294         if (pvolume_info->no_xattr)
3295                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3296         if (pvolume_info->sfu_emul)
3297                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3298         if (pvolume_info->nobrl)
3299                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3300         if (pvolume_info->nostrictsync)
3301                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3302         if (pvolume_info->mand_lock)
3303                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3304         if (pvolume_info->rwpidforward)
3305                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3306         if (pvolume_info->cifs_acl)
3307                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3308         if (pvolume_info->backupuid_specified)
3309                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3310         if (pvolume_info->backupgid_specified)
3311                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3312         if (pvolume_info->override_uid)
3313                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3314         if (pvolume_info->override_gid)
3315                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3316         if (pvolume_info->dynperm)
3317                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3318         if (pvolume_info->fsc)
3319                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3320         if (pvolume_info->multiuser)
3321                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3322                                             CIFS_MOUNT_NO_PERM);
3323         if (pvolume_info->strict_io)
3324                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3325         if (pvolume_info->direct_io) {
3326                 cFYI(1, "mounting share using direct i/o");
3327                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3328         }
3329         if (pvolume_info->mfsymlinks) {
3330                 if (pvolume_info->sfu_emul) {
3331                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
3332                                    "mount option is used");
3333                 } else {
3334                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3335                 }
3336         }
3337
3338         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3339                 cERROR(1, "mount option dynperm ignored if cifsacl "
3340                            "mount option supported");
3341 }
3342
3343 /*
3344  * When the server supports very large reads and writes via POSIX extensions,
3345  * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3346  * including the RFC1001 length.
3347  *
3348  * Note that this might make for "interesting" allocation problems during
3349  * writeback however as we have to allocate an array of pointers for the
3350  * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3351  *
3352  * For reads, there is a similar problem as we need to allocate an array
3353  * of kvecs to handle the receive, though that should only need to be done
3354  * once.
3355  */
3356 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3357 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3358
3359 /*
3360  * When the server doesn't allow large posix writes, only allow a rsize/wsize
3361  * of 2^17-1 minus the size of the call header. That allows for a read or
3362  * write up to the maximum size described by RFC1002.
3363  */
3364 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3365 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3366
3367 /*
3368  * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3369  * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3370  * a single wsize request with a single call.
3371  */
3372 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3373
3374 /*
3375  * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3376  * those values when posix extensions aren't in force. In actuality here, we
3377  * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3378  * to be ok with the extra byte even though Windows doesn't send writes that
3379  * are that large.
3380  *
3381  * Citation:
3382  *
3383  * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3384  */
3385 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3386 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3387
3388 static unsigned int
3389 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3390 {
3391         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3392         struct TCP_Server_Info *server = tcon->ses->server;
3393         unsigned int wsize;
3394
3395         /* start with specified wsize, or default */
3396         if (pvolume_info->wsize)
3397                 wsize = pvolume_info->wsize;
3398         else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3399                 wsize = CIFS_DEFAULT_IOSIZE;
3400         else
3401                 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3402
3403         /* can server support 24-bit write sizes? (via UNIX extensions) */
3404         if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3405                 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3406
3407         /*
3408          * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3409          * Limit it to max buffer offered by the server, minus the size of the
3410          * WRITEX header, not including the 4 byte RFC1001 length.
3411          */
3412         if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3413             (!(server->capabilities & CAP_UNIX) &&
3414              (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3415                 wsize = min_t(unsigned int, wsize,
3416                                 server->maxBuf - sizeof(WRITE_REQ) + 4);
3417
3418         /* hard limit of CIFS_MAX_WSIZE */
3419         wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3420
3421         return wsize;
3422 }
3423
3424 static unsigned int
3425 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3426 {
3427         __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3428         struct TCP_Server_Info *server = tcon->ses->server;
3429         unsigned int rsize, defsize;
3430
3431         /*
3432          * Set default value...
3433          *
3434          * HACK alert! Ancient servers have very small buffers. Even though
3435          * MS-CIFS indicates that servers are only limited by the client's
3436          * bufsize for reads, testing against win98se shows that it throws
3437          * INVALID_PARAMETER errors if you try to request too large a read.
3438          *
3439          * If the server advertises a MaxBufferSize of less than one page,
3440          * assume that it also can't satisfy reads larger than that either.
3441          *
3442          * FIXME: Is there a better heuristic for this?
3443          */
3444         if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3445                 defsize = CIFS_DEFAULT_IOSIZE;
3446         else if (server->capabilities & CAP_LARGE_READ_X)
3447                 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3448         else if (server->maxBuf >= PAGE_CACHE_SIZE)
3449                 defsize = CIFSMaxBufSize;
3450         else
3451                 defsize = server->maxBuf - sizeof(READ_RSP);
3452
3453         rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3454
3455         /*
3456          * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3457          * the client's MaxBufferSize.
3458          */
3459         if (!(server->capabilities & CAP_LARGE_READ_X))
3460                 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3461
3462         /* hard limit of CIFS_MAX_RSIZE */
3463         rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3464
3465         return rsize;
3466 }
3467
3468 static int
3469 is_path_accessible(int xid, struct cifs_tcon *tcon,
3470                    struct cifs_sb_info *cifs_sb, const char *full_path)
3471 {
3472         int rc;
3473         FILE_ALL_INFO *pfile_info;
3474
3475         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3476         if (pfile_info == NULL)
3477                 return -ENOMEM;
3478
3479         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3480                               0 /* not legacy */, cifs_sb->local_nls,
3481                               cifs_sb->mnt_cifs_flags &
3482                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
3483
3484         if (rc == -EOPNOTSUPP || rc == -EINVAL)
3485                 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3486                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3487                                   CIFS_MOUNT_MAP_SPECIAL_CHR);
3488         kfree(pfile_info);
3489         return rc;
3490 }
3491
3492 static void
3493 cleanup_volume_info_contents(struct smb_vol *volume_info)
3494 {
3495         kfree(volume_info->username);
3496         kzfree(volume_info->password);
3497         if (volume_info->UNCip != volume_info->UNC + 2)
3498                 kfree(volume_info->UNCip);
3499         kfree(volume_info->UNC);
3500         kfree(volume_info->domainname);
3501         kfree(volume_info->iocharset);
3502         kfree(volume_info->prepath);
3503 }
3504
3505 void
3506 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3507 {
3508         if (!volume_info)
3509                 return;
3510         cleanup_volume_info_contents(volume_info);
3511         kfree(volume_info);
3512 }
3513
3514
3515 #ifdef CONFIG_CIFS_DFS_UPCALL
3516 /* build_path_to_root returns full path to root when
3517  * we do not have an exiting connection (tcon) */
3518 static char *
3519 build_unc_path_to_root(const struct smb_vol *vol,
3520                 const struct cifs_sb_info *cifs_sb)
3521 {
3522         char *full_path, *pos;
3523         unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3524         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3525
3526         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3527         if (full_path == NULL)
3528                 return ERR_PTR(-ENOMEM);
3529
3530         strncpy(full_path, vol->UNC, unc_len);
3531         pos = full_path + unc_len;
3532
3533         if (pplen) {
3534                 strncpy(pos, vol->prepath, pplen);
3535                 pos += pplen;
3536         }
3537
3538         *pos = '\0'; /* add trailing null */
3539         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3540         cFYI(1, "%s: full_path=%s", __func__, full_path);
3541         return full_path;
3542 }
3543
3544 /*
3545  * Perform a dfs referral query for a share and (optionally) prefix
3546  *
3547  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3548  * to a string containing updated options for the submount.  Otherwise it
3549  * will be left untouched.
3550  *
3551  * Returns the rc from get_dfs_path to the caller, which can be used to
3552  * determine whether there were referrals.
3553  */
3554 static int
3555 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3556                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3557                     int check_prefix)
3558 {
3559         int rc;
3560         unsigned int num_referrals = 0;
3561         struct dfs_info3_param *referrals = NULL;
3562         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3563
3564         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3565         if (IS_ERR(full_path))
3566                 return PTR_ERR(full_path);
3567
3568         /* For DFS paths, skip the first '\' of the UNC */
3569         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3570
3571         rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3572                           &num_referrals, &referrals,
3573                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3574
3575         if (!rc && num_referrals > 0) {
3576                 char *fake_devname = NULL;
3577
3578                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3579                                                    full_path + 1, referrals,
3580                                                    &fake_devname);
3581
3582                 free_dfs_info_array(referrals, num_referrals);
3583
3584                 if (IS_ERR(mdata)) {
3585                         rc = PTR_ERR(mdata);
3586                         mdata = NULL;
3587                 } else {
3588                         cleanup_volume_info_contents(volume_info);
3589                         memset(volume_info, '\0', sizeof(*volume_info));
3590                         rc = cifs_setup_volume_info(volume_info, mdata,
3591                                                         fake_devname);
3592                 }
3593                 kfree(fake_devname);
3594                 kfree(cifs_sb->mountdata);
3595                 cifs_sb->mountdata = mdata;
3596         }
3597         kfree(full_path);
3598         return rc;
3599 }
3600 #endif
3601
3602 static int
3603 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3604                         const char *devname)
3605 {
3606         int rc = 0;
3607
3608         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3609                 return -EINVAL;
3610
3611         if (volume_info->nullauth) {
3612                 cFYI(1, "Anonymous login");
3613                 kfree(volume_info->username);
3614                 volume_info->username = NULL;
3615         } else if (volume_info->username) {
3616                 /* BB fixme parse for domain name here */
3617                 cFYI(1, "Username: %s", volume_info->username);
3618         } else {
3619                 cifserror("No username specified");
3620         /* In userspace mount helper we can get user name from alternate
3621            locations such as env variables and files on disk */
3622                 return -EINVAL;
3623         }
3624
3625         /* this is needed for ASCII cp to Unicode converts */
3626         if (volume_info->iocharset == NULL) {
3627                 /* load_nls_default cannot return null */
3628                 volume_info->local_nls = load_nls_default();
3629         } else {
3630                 volume_info->local_nls = load_nls(volume_info->iocharset);
3631                 if (volume_info->local_nls == NULL) {
3632                         cERROR(1, "CIFS mount error: iocharset %s not found",
3633                                  volume_info->iocharset);
3634                         return -ELIBACC;
3635                 }
3636         }
3637
3638         return rc;
3639 }
3640
3641 struct smb_vol *
3642 cifs_get_volume_info(char *mount_data, const char *devname)
3643 {
3644         int rc;
3645         struct smb_vol *volume_info;
3646
3647         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3648         if (!volume_info)
3649                 return ERR_PTR(-ENOMEM);
3650
3651         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3652         if (rc) {
3653                 cifs_cleanup_volume_info(volume_info);
3654                 volume_info = ERR_PTR(rc);
3655         }
3656
3657         return volume_info;
3658 }
3659
3660 /* make sure ra_pages is a multiple of rsize */
3661 static inline unsigned int
3662 cifs_ra_pages(struct cifs_sb_info *cifs_sb)
3663 {
3664         unsigned int reads;
3665         unsigned int rsize_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3666
3667         if (rsize_pages >= default_backing_dev_info.ra_pages)
3668                 return default_backing_dev_info.ra_pages;
3669         else if (rsize_pages == 0)
3670                 return rsize_pages;
3671
3672         reads = default_backing_dev_info.ra_pages / rsize_pages;
3673         return reads * rsize_pages;
3674 }
3675
3676 int
3677 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3678 {
3679         int rc;
3680         int xid;
3681         struct cifs_ses *pSesInfo;
3682         struct cifs_tcon *tcon;
3683         struct TCP_Server_Info *srvTcp;
3684         char   *full_path;
3685         struct tcon_link *tlink;
3686 #ifdef CONFIG_CIFS_DFS_UPCALL
3687         int referral_walks_count = 0;
3688 #endif
3689
3690         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3691         if (rc)
3692                 return rc;
3693
3694 #ifdef CONFIG_CIFS_DFS_UPCALL
3695 try_mount_again:
3696         /* cleanup activities if we're chasing a referral */
3697         if (referral_walks_count) {
3698                 if (tcon)
3699                         cifs_put_tcon(tcon);
3700                 else if (pSesInfo)
3701                         cifs_put_smb_ses(pSesInfo);
3702
3703                 FreeXid(xid);
3704         }
3705 #endif
3706         rc = 0;
3707         tcon = NULL;
3708         pSesInfo = NULL;
3709         srvTcp = NULL;
3710         full_path = NULL;
3711         tlink = NULL;
3712
3713         xid = GetXid();
3714
3715         /* get a reference to a tcp session */
3716         srvTcp = cifs_get_tcp_session(volume_info);
3717         if (IS_ERR(srvTcp)) {
3718                 rc = PTR_ERR(srvTcp);
3719                 bdi_destroy(&cifs_sb->bdi);
3720                 goto out;
3721         }
3722
3723         /* get a reference to a SMB session */
3724         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3725         if (IS_ERR(pSesInfo)) {
3726                 rc = PTR_ERR(pSesInfo);
3727                 pSesInfo = NULL;
3728                 goto mount_fail_check;
3729         }
3730
3731         /* search for existing tcon to this server share */
3732         tcon = cifs_get_tcon(pSesInfo, volume_info);
3733         if (IS_ERR(tcon)) {
3734                 rc = PTR_ERR(tcon);
3735                 tcon = NULL;
3736                 goto remote_path_check;
3737         }
3738
3739         /* tell server which Unix caps we support */
3740         if (tcon->ses->capabilities & CAP_UNIX) {
3741                 /* reset of caps checks mount to see if unix extensions
3742                    disabled for just this mount */
3743                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3744                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3745                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3746                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3747                         rc = -EACCES;
3748                         goto mount_fail_check;
3749                 }
3750         } else
3751                 tcon->unix_ext = 0; /* server does not support them */
3752
3753         /* do not care if following two calls succeed - informational */
3754         if (!tcon->ipc) {
3755                 CIFSSMBQFSDeviceInfo(xid, tcon);
3756                 CIFSSMBQFSAttributeInfo(xid, tcon);
3757         }
3758
3759         cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3760         cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3761
3762         /* tune readahead according to rsize */
3763         cifs_sb->bdi.ra_pages = cifs_ra_pages(cifs_sb);
3764
3765 remote_path_check:
3766 #ifdef CONFIG_CIFS_DFS_UPCALL
3767         /*
3768          * Perform an unconditional check for whether there are DFS
3769          * referrals for this path without prefix, to provide support
3770          * for DFS referrals from w2k8 servers which don't seem to respond
3771          * with PATH_NOT_COVERED to requests that include the prefix.
3772          * Chase the referral if found, otherwise continue normally.
3773          */
3774         if (referral_walks_count == 0) {
3775                 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3776                                                 cifs_sb, false);
3777                 if (!refrc) {
3778                         referral_walks_count++;
3779                         goto try_mount_again;
3780                 }
3781         }
3782 #endif
3783
3784         /* check if a whole path is not remote */
3785         if (!rc && tcon) {
3786                 /* build_path_to_root works only when we have a valid tcon */
3787                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3788                 if (full_path == NULL) {
3789                         rc = -ENOMEM;
3790                         goto mount_fail_check;
3791                 }
3792                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3793                 if (rc != 0 && rc != -EREMOTE) {
3794                         kfree(full_path);
3795                         goto mount_fail_check;
3796                 }
3797                 kfree(full_path);
3798         }
3799
3800         /* get referral if needed */
3801         if (rc == -EREMOTE) {
3802 #ifdef CONFIG_CIFS_DFS_UPCALL
3803                 if (referral_walks_count > MAX_NESTED_LINKS) {
3804                         /*
3805                          * BB: when we implement proper loop detection,
3806                          *     we will remove this check. But now we need it
3807                          *     to prevent an indefinite loop if 'DFS tree' is
3808                          *     misconfigured (i.e. has loops).
3809                          */
3810                         rc = -ELOOP;
3811                         goto mount_fail_check;
3812                 }
3813
3814                 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3815                                          true);
3816
3817                 if (!rc) {
3818                         referral_walks_count++;
3819                         goto try_mount_again;
3820                 }
3821                 goto mount_fail_check;
3822 #else /* No DFS support, return error on mount */
3823                 rc = -EOPNOTSUPP;
3824 #endif
3825         }
3826
3827         if (rc)
3828                 goto mount_fail_check;
3829
3830         /* now, hang the tcon off of the superblock */
3831         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3832         if (tlink == NULL) {
3833                 rc = -ENOMEM;
3834                 goto mount_fail_check;
3835         }
3836
3837         tlink->tl_uid = pSesInfo->linux_uid;
3838         tlink->tl_tcon = tcon;
3839         tlink->tl_time = jiffies;
3840         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3841         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3842
3843         cifs_sb->master_tlink = tlink;
3844         spin_lock(&cifs_sb->tlink_tree_lock);
3845         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3846         spin_unlock(&cifs_sb->tlink_tree_lock);
3847
3848         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3849                                 TLINK_IDLE_EXPIRE);
3850
3851 mount_fail_check:
3852         /* on error free sesinfo and tcon struct if needed */
3853         if (rc) {
3854                 /* If find_unc succeeded then rc == 0 so we can not end */
3855                 /* up accidentally freeing someone elses tcon struct */
3856                 if (tcon)
3857                         cifs_put_tcon(tcon);
3858                 else if (pSesInfo)
3859                         cifs_put_smb_ses(pSesInfo);
3860                 else
3861                         cifs_put_tcp_session(srvTcp);
3862                 bdi_destroy(&cifs_sb->bdi);
3863         }
3864
3865 out:
3866         FreeXid(xid);
3867         return rc;
3868 }
3869
3870 /*
3871  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3872  * pointer may be NULL.
3873  */
3874 int
3875 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3876          const char *tree, struct cifs_tcon *tcon,
3877          const struct nls_table *nls_codepage)
3878 {
3879         struct smb_hdr *smb_buffer;
3880         struct smb_hdr *smb_buffer_response;
3881         TCONX_REQ *pSMB;
3882         TCONX_RSP *pSMBr;
3883         unsigned char *bcc_ptr;
3884         int rc = 0;
3885         int length;
3886         __u16 bytes_left, count;
3887
3888         if (ses == NULL)
3889                 return -EIO;
3890
3891         smb_buffer = cifs_buf_get();
3892         if (smb_buffer == NULL)
3893                 return -ENOMEM;
3894
3895         smb_buffer_response = smb_buffer;
3896
3897         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3898                         NULL /*no tid */ , 4 /*wct */ );
3899
3900         smb_buffer->Mid = GetNextMid(ses->server);
3901         smb_buffer->Uid = ses->Suid;
3902         pSMB = (TCONX_REQ *) smb_buffer;
3903         pSMBr = (TCONX_RSP *) smb_buffer_response;
3904
3905         pSMB->AndXCommand = 0xFF;
3906         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3907         bcc_ptr = &pSMB->Password[0];
3908         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3909                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3910                 *bcc_ptr = 0; /* password is null byte */
3911                 bcc_ptr++;              /* skip password */
3912                 /* already aligned so no need to do it below */
3913         } else {
3914                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3915                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3916                    specified as required (when that support is added to
3917                    the vfs in the future) as only NTLM or the much
3918                    weaker LANMAN (which we do not send by default) is accepted
3919                    by Samba (not sure whether other servers allow
3920                    NTLMv2 password here) */
3921 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3922                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3923                     (ses->server->secType == LANMAN))
3924                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3925                                          ses->server->sec_mode &
3926                                             SECMODE_PW_ENCRYPT ? true : false,
3927                                          bcc_ptr);
3928                 else
3929 #endif /* CIFS_WEAK_PW_HASH */
3930                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3931                                         bcc_ptr, nls_codepage);
3932
3933                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3934                 if (ses->capabilities & CAP_UNICODE) {
3935                         /* must align unicode strings */
3936                         *bcc_ptr = 0; /* null byte password */
3937                         bcc_ptr++;
3938                 }
3939         }
3940
3941         if (ses->server->sec_mode &
3942                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3943                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3944
3945         if (ses->capabilities & CAP_STATUS32) {
3946                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3947         }
3948         if (ses->capabilities & CAP_DFS) {
3949                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3950         }
3951         if (ses->capabilities & CAP_UNICODE) {
3952                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3953                 length =
3954                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3955                         6 /* max utf8 char length in bytes */ *
3956                         (/* server len*/ + 256 /* share len */), nls_codepage);
3957                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3958                 bcc_ptr += 2;   /* skip trailing null */
3959         } else {                /* ASCII */
3960                 strcpy(bcc_ptr, tree);
3961                 bcc_ptr += strlen(tree) + 1;
3962         }
3963         strcpy(bcc_ptr, "?????");
3964         bcc_ptr += strlen("?????");
3965         bcc_ptr += 1;
3966         count = bcc_ptr - &pSMB->Password[0];
3967         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3968                                         pSMB->hdr.smb_buf_length) + count);
3969         pSMB->ByteCount = cpu_to_le16(count);
3970
3971         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3972                          0);
3973
3974         /* above now done in SendReceive */
3975         if ((rc == 0) && (tcon != NULL)) {
3976                 bool is_unicode;
3977
3978                 tcon->tidStatus = CifsGood;
3979                 tcon->need_reconnect = false;
3980                 tcon->tid = smb_buffer_response->Tid;
3981                 bcc_ptr = pByteArea(smb_buffer_response);
3982                 bytes_left = get_bcc(smb_buffer_response);
3983                 length = strnlen(bcc_ptr, bytes_left - 2);
3984                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3985                         is_unicode = true;
3986                 else
3987                         is_unicode = false;
3988
3989
3990                 /* skip service field (NB: this field is always ASCII) */
3991                 if (length == 3) {
3992                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3993                             (bcc_ptr[2] == 'C')) {
3994                                 cFYI(1, "IPC connection");
3995                                 tcon->ipc = 1;
3996                         }
3997                 } else if (length == 2) {
3998                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3999                                 /* the most common case */
4000                                 cFYI(1, "disk share connection");
4001                         }
4002                 }
4003                 bcc_ptr += length + 1;
4004                 bytes_left -= (length + 1);
4005                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4006
4007                 /* mostly informational -- no need to fail on error here */
4008                 kfree(tcon->nativeFileSystem);
4009                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4010                                                       bytes_left, is_unicode,
4011                                                       nls_codepage);
4012
4013                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4014
4015                 if ((smb_buffer_response->WordCount == 3) ||
4016                          (smb_buffer_response->WordCount == 7))
4017                         /* field is in same location */
4018                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4019                 else
4020                         tcon->Flags = 0;
4021                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4022         } else if ((rc == 0) && tcon == NULL) {
4023                 /* all we need to save for IPC$ connection */
4024                 ses->ipc_tid = smb_buffer_response->Tid;
4025         }
4026
4027         cifs_buf_release(smb_buffer);
4028         return rc;
4029 }
4030
4031 void
4032 cifs_umount(struct cifs_sb_info *cifs_sb)
4033 {
4034         struct rb_root *root = &cifs_sb->tlink_tree;
4035         struct rb_node *node;
4036         struct tcon_link *tlink;
4037
4038         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4039
4040         spin_lock(&cifs_sb->tlink_tree_lock);
4041         while ((node = rb_first(root))) {
4042                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4043                 cifs_get_tlink(tlink);
4044                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4045                 rb_erase(node, root);
4046
4047                 spin_unlock(&cifs_sb->tlink_tree_lock);
4048                 cifs_put_tlink(tlink);
4049                 spin_lock(&cifs_sb->tlink_tree_lock);
4050         }
4051         spin_unlock(&cifs_sb->tlink_tree_lock);
4052
4053         bdi_destroy(&cifs_sb->bdi);
4054         kfree(cifs_sb->mountdata);
4055         unload_nls(cifs_sb->local_nls);
4056         kfree(cifs_sb);
4057 }
4058
4059 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
4060 {
4061         int rc = 0;
4062         struct TCP_Server_Info *server = ses->server;
4063
4064         /* only send once per connect */
4065         if (server->maxBuf != 0)
4066                 return 0;
4067
4068         cifs_set_credits(server, 1);
4069         rc = CIFSSMBNegotiate(xid, ses);
4070         if (rc == -EAGAIN) {
4071                 /* retry only once on 1st time connection */
4072                 cifs_set_credits(server, 1);
4073                 rc = CIFSSMBNegotiate(xid, ses);
4074                 if (rc == -EAGAIN)
4075                         rc = -EHOSTDOWN;
4076         }
4077         if (rc == 0) {
4078                 spin_lock(&GlobalMid_Lock);
4079                 if (server->tcpStatus == CifsNeedNegotiate)
4080                         server->tcpStatus = CifsGood;
4081                 else
4082                         rc = -EHOSTDOWN;
4083                 spin_unlock(&GlobalMid_Lock);
4084
4085         }
4086
4087         return rc;
4088 }
4089
4090
4091 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4092                         struct nls_table *nls_info)
4093 {
4094         int rc = 0;
4095         struct TCP_Server_Info *server = ses->server;
4096
4097         ses->flags = 0;
4098         ses->capabilities = server->capabilities;
4099         if (linuxExtEnabled == 0)
4100                 ses->capabilities &= (~CAP_UNIX);
4101
4102         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4103                  server->sec_mode, server->capabilities, server->timeAdj);
4104
4105         rc = CIFS_SessSetup(xid, ses, nls_info);
4106         if (rc) {
4107                 cERROR(1, "Send error in SessSetup = %d", rc);
4108         } else {
4109                 mutex_lock(&ses->server->srv_mutex);
4110                 if (!server->session_estab) {
4111                         server->session_key.response = ses->auth_key.response;
4112                         server->session_key.len = ses->auth_key.len;
4113                         server->sequence_number = 0x2;
4114                         server->session_estab = true;
4115                         ses->auth_key.response = NULL;
4116                 }
4117                 mutex_unlock(&server->srv_mutex);
4118
4119                 cFYI(1, "CIFS Session Established successfully");
4120                 spin_lock(&GlobalMid_Lock);
4121                 ses->status = CifsGood;
4122                 ses->need_reconnect = false;
4123                 spin_unlock(&GlobalMid_Lock);
4124         }
4125
4126         kfree(ses->auth_key.response);
4127         ses->auth_key.response = NULL;
4128         ses->auth_key.len = 0;
4129         kfree(ses->ntlmssp);
4130         ses->ntlmssp = NULL;
4131
4132         return rc;
4133 }
4134
4135 static int
4136 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4137 {
4138         switch (ses->server->secType) {
4139         case Kerberos:
4140                 vol->secFlg = CIFSSEC_MUST_KRB5;
4141                 return 0;
4142         case NTLMv2:
4143                 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4144                 break;
4145         case NTLM:
4146                 vol->secFlg = CIFSSEC_MUST_NTLM;
4147                 break;
4148         case RawNTLMSSP:
4149                 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4150                 break;
4151         case LANMAN:
4152                 vol->secFlg = CIFSSEC_MUST_LANMAN;
4153                 break;
4154         }
4155
4156         return cifs_set_cifscreds(vol, ses);
4157 }
4158
4159 static struct cifs_tcon *
4160 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4161 {
4162         int rc;
4163         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4164         struct cifs_ses *ses;
4165         struct cifs_tcon *tcon = NULL;
4166         struct smb_vol *vol_info;
4167
4168         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4169         if (vol_info == NULL)
4170                 return ERR_PTR(-ENOMEM);
4171
4172         vol_info->local_nls = cifs_sb->local_nls;
4173         vol_info->linux_uid = fsuid;
4174         vol_info->cred_uid = fsuid;
4175         vol_info->UNC = master_tcon->treeName;
4176         vol_info->retry = master_tcon->retry;
4177         vol_info->nocase = master_tcon->nocase;
4178         vol_info->local_lease = master_tcon->local_lease;
4179         vol_info->no_linux_ext = !master_tcon->unix_ext;
4180
4181         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4182         if (rc) {
4183                 tcon = ERR_PTR(rc);
4184                 goto out;
4185         }
4186
4187         /* get a reference for the same TCP session */
4188         spin_lock(&cifs_tcp_ses_lock);
4189         ++master_tcon->ses->server->srv_count;
4190         spin_unlock(&cifs_tcp_ses_lock);
4191
4192         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4193         if (IS_ERR(ses)) {
4194                 tcon = (struct cifs_tcon *)ses;
4195                 cifs_put_tcp_session(master_tcon->ses->server);
4196                 goto out;
4197         }
4198
4199         tcon = cifs_get_tcon(ses, vol_info);
4200         if (IS_ERR(tcon)) {
4201                 cifs_put_smb_ses(ses);
4202                 goto out;
4203         }
4204
4205         if (ses->capabilities & CAP_UNIX)
4206                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4207 out:
4208         kfree(vol_info->username);
4209         kfree(vol_info->password);
4210         kfree(vol_info);
4211
4212         return tcon;
4213 }
4214
4215 struct cifs_tcon *
4216 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4217 {
4218         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4219 }
4220
4221 static int
4222 cifs_sb_tcon_pending_wait(void *unused)
4223 {
4224         schedule();
4225         return signal_pending(current) ? -ERESTARTSYS : 0;
4226 }
4227
4228 /* find and return a tlink with given uid */
4229 static struct tcon_link *
4230 tlink_rb_search(struct rb_root *root, uid_t uid)
4231 {
4232         struct rb_node *node = root->rb_node;
4233         struct tcon_link *tlink;
4234
4235         while (node) {
4236                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4237
4238                 if (tlink->tl_uid > uid)
4239                         node = node->rb_left;
4240                 else if (tlink->tl_uid < uid)
4241                         node = node->rb_right;
4242                 else
4243                         return tlink;
4244         }
4245         return NULL;
4246 }
4247
4248 /* insert a tcon_link into the tree */
4249 static void
4250 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4251 {
4252         struct rb_node **new = &(root->rb_node), *parent = NULL;
4253         struct tcon_link *tlink;
4254
4255         while (*new) {
4256                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4257                 parent = *new;
4258
4259                 if (tlink->tl_uid > new_tlink->tl_uid)
4260                         new = &((*new)->rb_left);
4261                 else
4262                         new = &((*new)->rb_right);
4263         }
4264
4265         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4266         rb_insert_color(&new_tlink->tl_rbnode, root);
4267 }
4268
4269 /*
4270  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4271  * current task.
4272  *
4273  * If the superblock doesn't refer to a multiuser mount, then just return
4274  * the master tcon for the mount.
4275  *
4276  * First, search the rbtree for an existing tcon for this fsuid. If one
4277  * exists, then check to see if it's pending construction. If it is then wait
4278  * for construction to complete. Once it's no longer pending, check to see if
4279  * it failed and either return an error or retry construction, depending on
4280  * the timeout.
4281  *
4282  * If one doesn't exist then insert a new tcon_link struct into the tree and
4283  * try to construct a new one.
4284  */
4285 struct tcon_link *
4286 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4287 {
4288         int ret;
4289         uid_t fsuid = current_fsuid();
4290         struct tcon_link *tlink, *newtlink;
4291
4292         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4293                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4294
4295         spin_lock(&cifs_sb->tlink_tree_lock);
4296         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4297         if (tlink)
4298                 cifs_get_tlink(tlink);
4299         spin_unlock(&cifs_sb->tlink_tree_lock);
4300
4301         if (tlink == NULL) {
4302                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4303                 if (newtlink == NULL)
4304                         return ERR_PTR(-ENOMEM);
4305                 newtlink->tl_uid = fsuid;
4306                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4307                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4308                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4309                 cifs_get_tlink(newtlink);
4310
4311                 spin_lock(&cifs_sb->tlink_tree_lock);
4312                 /* was one inserted after previous search? */
4313                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4314                 if (tlink) {
4315                         cifs_get_tlink(tlink);
4316                         spin_unlock(&cifs_sb->tlink_tree_lock);
4317                         kfree(newtlink);
4318                         goto wait_for_construction;
4319                 }
4320                 tlink = newtlink;
4321                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4322                 spin_unlock(&cifs_sb->tlink_tree_lock);
4323         } else {
4324 wait_for_construction:
4325                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4326                                   cifs_sb_tcon_pending_wait,
4327                                   TASK_INTERRUPTIBLE);
4328                 if (ret) {
4329                         cifs_put_tlink(tlink);
4330                         return ERR_PTR(ret);
4331                 }
4332
4333                 /* if it's good, return it */
4334                 if (!IS_ERR(tlink->tl_tcon))
4335                         return tlink;
4336
4337                 /* return error if we tried this already recently */
4338                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4339                         cifs_put_tlink(tlink);
4340                         return ERR_PTR(-EACCES);
4341                 }
4342
4343                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4344                         goto wait_for_construction;
4345         }
4346
4347         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4348         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4349         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4350
4351         if (IS_ERR(tlink->tl_tcon)) {
4352                 cifs_put_tlink(tlink);
4353                 return ERR_PTR(-EACCES);
4354         }
4355
4356         return tlink;
4357 }
4358
4359 /*
4360  * periodic workqueue job that scans tcon_tree for a superblock and closes
4361  * out tcons.
4362  */
4363 static void
4364 cifs_prune_tlinks(struct work_struct *work)
4365 {
4366         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4367                                                     prune_tlinks.work);
4368         struct rb_root *root = &cifs_sb->tlink_tree;
4369         struct rb_node *node = rb_first(root);
4370         struct rb_node *tmp;
4371         struct tcon_link *tlink;
4372
4373         /*
4374          * Because we drop the spinlock in the loop in order to put the tlink
4375          * it's not guarded against removal of links from the tree. The only
4376          * places that remove entries from the tree are this function and
4377          * umounts. Because this function is non-reentrant and is canceled
4378          * before umount can proceed, this is safe.
4379          */
4380         spin_lock(&cifs_sb->tlink_tree_lock);
4381         node = rb_first(root);
4382         while (node != NULL) {
4383                 tmp = node;
4384                 node = rb_next(tmp);
4385                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4386
4387                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4388                     atomic_read(&tlink->tl_count) != 0 ||
4389                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4390                         continue;
4391
4392                 cifs_get_tlink(tlink);
4393                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4394                 rb_erase(tmp, root);
4395
4396                 spin_unlock(&cifs_sb->tlink_tree_lock);
4397                 cifs_put_tlink(tlink);
4398                 spin_lock(&cifs_sb->tlink_tree_lock);
4399         }
4400         spin_unlock(&cifs_sb->tlink_tree_lock);
4401
4402         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4403                                 TLINK_IDLE_EXPIRE);
4404 }