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