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