fs/cifs/connect.c

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