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