fs/cifs/connect.c

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