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