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