fs/cifs/connect.c

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