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