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