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