fs/cifs/connect.c

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