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