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