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 (server->ops->select_sectype(server, vol->sectype)
2078              == Unspecified)
2079                 return false;
2080
2081         /*
2082          * Now check if signing mode is acceptable. No need to check
2083          * global_secflags at this point since if MUST_SIGN is set then
2084          * the server->sign had better be too.
2085          */
2086         if (vol->sign && !server->sign)
2087                 return false;
2088
2089         return true;
2090 }
2091
2092 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2093 {
2094         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2095
2096         if (vol->nosharesock)
2097                 return 0;
2098
2099         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2100                 return 0;
2101
2102         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2103                 return 0;
2104
2105         if (!match_address(server, addr,
2106                            (struct sockaddr *)&vol->srcaddr))
2107                 return 0;
2108
2109         if (!match_port(server, addr))
2110                 return 0;
2111
2112         if (!match_security(server, vol))
2113                 return 0;
2114
2115         if (server->echo_interval != vol->echo_interval * HZ)
2116                 return 0;
2117
2118         return 1;
2119 }
2120
2121 static struct TCP_Server_Info *
2122 cifs_find_tcp_session(struct smb_vol *vol)
2123 {
2124         struct TCP_Server_Info *server;
2125
2126         spin_lock(&cifs_tcp_ses_lock);
2127         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2128                 if (!match_server(server, vol))
2129                         continue;
2130
2131                 ++server->srv_count;
2132                 spin_unlock(&cifs_tcp_ses_lock);
2133                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2134                 return server;
2135         }
2136         spin_unlock(&cifs_tcp_ses_lock);
2137         return NULL;
2138 }
2139
2140 void
2141 cifs_put_tcp_session(struct TCP_Server_Info *server, int from_reconnect)
2142 {
2143         struct task_struct *task;
2144
2145         spin_lock(&cifs_tcp_ses_lock);
2146         if (--server->srv_count > 0) {
2147                 spin_unlock(&cifs_tcp_ses_lock);
2148                 return;
2149         }
2150
2151         put_net(cifs_net_ns(server));
2152
2153         list_del_init(&server->tcp_ses_list);
2154         spin_unlock(&cifs_tcp_ses_lock);
2155
2156         cancel_delayed_work_sync(&server->echo);
2157
2158 #ifdef CONFIG_CIFS_SMB2
2159         if (from_reconnect)
2160                 /*
2161                  * Avoid deadlock here: reconnect work calls
2162                  * cifs_put_tcp_session() at its end. Need to be sure
2163                  * that reconnect work does nothing with server pointer after
2164                  * that step.
2165                  */
2166                 cancel_delayed_work(&server->reconnect);
2167         else
2168                 cancel_delayed_work_sync(&server->reconnect);
2169 #endif
2170
2171         spin_lock(&GlobalMid_Lock);
2172         server->tcpStatus = CifsExiting;
2173         spin_unlock(&GlobalMid_Lock);
2174
2175         cifs_crypto_secmech_release(server);
2176         cifs_fscache_release_client_cookie(server);
2177
2178         kfree(server->session_key.response);
2179         server->session_key.response = NULL;
2180         server->session_key.len = 0;
2181
2182         task = xchg(&server->tsk, NULL);
2183         if (task)
2184                 force_sig(SIGKILL, task);
2185 }
2186
2187 static struct TCP_Server_Info *
2188 cifs_get_tcp_session(struct smb_vol *volume_info)
2189 {
2190         struct TCP_Server_Info *tcp_ses = NULL;
2191         int rc;
2192
2193         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2194
2195         /* see if we already have a matching tcp_ses */
2196         tcp_ses = cifs_find_tcp_session(volume_info);
2197         if (tcp_ses)
2198                 return tcp_ses;
2199
2200         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2201         if (!tcp_ses) {
2202                 rc = -ENOMEM;
2203                 goto out_err;
2204         }
2205
2206         tcp_ses->ops = volume_info->ops;
2207         tcp_ses->vals = volume_info->vals;
2208         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2209         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2210         if (IS_ERR(tcp_ses->hostname)) {
2211                 rc = PTR_ERR(tcp_ses->hostname);
2212                 goto out_err_crypto_release;
2213         }
2214
2215         tcp_ses->noblocksnd = volume_info->noblocksnd;
2216         tcp_ses->noautotune = volume_info->noautotune;
2217         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2218         tcp_ses->in_flight = 0;
2219         tcp_ses->credits = 1;
2220         init_waitqueue_head(&tcp_ses->response_q);
2221         init_waitqueue_head(&tcp_ses->request_q);
2222         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2223         mutex_init(&tcp_ses->srv_mutex);
2224         memcpy(tcp_ses->workstation_RFC1001_name,
2225                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2226         memcpy(tcp_ses->server_RFC1001_name,
2227                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2228         tcp_ses->session_estab = false;
2229         tcp_ses->sequence_number = 0;
2230         tcp_ses->lstrp = jiffies;
2231         spin_lock_init(&tcp_ses->req_lock);
2232         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2233         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2234         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2235 #ifdef CONFIG_CIFS_SMB2
2236         INIT_DELAYED_WORK(&tcp_ses->reconnect, smb2_reconnect_server);
2237         mutex_init(&tcp_ses->reconnect_mutex);
2238 #endif
2239         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2240                sizeof(tcp_ses->srcaddr));
2241         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2242                 sizeof(tcp_ses->dstaddr));
2243 #ifdef CONFIG_CIFS_SMB2
2244         generate_random_uuid(tcp_ses->client_guid);
2245 #endif
2246         /*
2247          * at this point we are the only ones with the pointer
2248          * to the struct since the kernel thread not created yet
2249          * no need to spinlock this init of tcpStatus or srv_count
2250          */
2251         tcp_ses->tcpStatus = CifsNew;
2252         ++tcp_ses->srv_count;
2253
2254         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2255                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2256                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2257         else
2258                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2259
2260         rc = ip_connect(tcp_ses);
2261         if (rc < 0) {
2262                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2263                 goto out_err_crypto_release;
2264         }
2265
2266         /*
2267          * since we're in a cifs function already, we know that
2268          * this will succeed. No need for try_module_get().
2269          */
2270         __module_get(THIS_MODULE);
2271         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2272                                   tcp_ses, "cifsd");
2273         if (IS_ERR(tcp_ses->tsk)) {
2274                 rc = PTR_ERR(tcp_ses->tsk);
2275                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2276                 module_put(THIS_MODULE);
2277                 goto out_err_crypto_release;
2278         }
2279         tcp_ses->tcpStatus = CifsNeedNegotiate;
2280
2281         /* thread spawned, put it on the list */
2282         spin_lock(&cifs_tcp_ses_lock);
2283         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2284         spin_unlock(&cifs_tcp_ses_lock);
2285
2286         cifs_fscache_get_client_cookie(tcp_ses);
2287
2288         /* queue echo request delayed work */
2289         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2290
2291         return tcp_ses;
2292
2293 out_err_crypto_release:
2294         cifs_crypto_secmech_release(tcp_ses);
2295
2296         put_net(cifs_net_ns(tcp_ses));
2297
2298 out_err:
2299         if (tcp_ses) {
2300                 if (!IS_ERR(tcp_ses->hostname))
2301                         kfree(tcp_ses->hostname);
2302                 if (tcp_ses->ssocket)
2303                         sock_release(tcp_ses->ssocket);
2304                 kfree(tcp_ses);
2305         }
2306         return ERR_PTR(rc);
2307 }
2308
2309 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2310 {
2311         if (vol->sectype != Unspecified &&
2312             vol->sectype != ses->sectype)
2313                 return 0;
2314
2315         switch (ses->sectype) {
2316         case Kerberos:
2317                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2318                         return 0;
2319                 break;
2320         default:
2321                 /* NULL username means anonymous session */
2322                 if (ses->user_name == NULL) {
2323                         if (!vol->nullauth)
2324                                 return 0;
2325                         break;
2326                 }
2327
2328                 /* anything else takes username/password */
2329                 if (strncmp(ses->user_name,
2330                             vol->username ? vol->username : "",
2331                             CIFS_MAX_USERNAME_LEN))
2332                         return 0;
2333                 if ((vol->username && strlen(vol->username) != 0) &&
2334                     ses->password != NULL &&
2335                     strncmp(ses->password,
2336                             vol->password ? vol->password : "",
2337                             CIFS_MAX_PASSWORD_LEN))
2338                         return 0;
2339         }
2340         return 1;
2341 }
2342
2343 static struct cifs_ses *
2344 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2345 {
2346         struct cifs_ses *ses;
2347
2348         spin_lock(&cifs_tcp_ses_lock);
2349         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2350                 if (ses->status == CifsExiting)
2351                         continue;
2352                 if (!match_session(ses, vol))
2353                         continue;
2354                 ++ses->ses_count;
2355                 spin_unlock(&cifs_tcp_ses_lock);
2356                 return ses;
2357         }
2358         spin_unlock(&cifs_tcp_ses_lock);
2359         return NULL;
2360 }
2361
2362 static void
2363 cifs_put_smb_ses(struct cifs_ses *ses)
2364 {
2365         unsigned int rc, xid;
2366         struct TCP_Server_Info *server = ses->server;
2367
2368         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2369
2370         spin_lock(&cifs_tcp_ses_lock);
2371         if (ses->status == CifsExiting) {
2372                 spin_unlock(&cifs_tcp_ses_lock);
2373                 return;
2374         }
2375         if (--ses->ses_count > 0) {
2376                 spin_unlock(&cifs_tcp_ses_lock);
2377                 return;
2378         }
2379         if (ses->status == CifsGood)
2380                 ses->status = CifsExiting;
2381         spin_unlock(&cifs_tcp_ses_lock);
2382
2383         if (ses->status == CifsExiting && server->ops->logoff) {
2384                 xid = get_xid();
2385                 rc = server->ops->logoff(xid, ses);
2386                 if (rc)
2387                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2388                                 __func__, rc);
2389                 _free_xid(xid);
2390         }
2391
2392         spin_lock(&cifs_tcp_ses_lock);
2393         list_del_init(&ses->smb_ses_list);
2394         spin_unlock(&cifs_tcp_ses_lock);
2395
2396         sesInfoFree(ses);
2397         cifs_put_tcp_session(server, 0);
2398 }
2399
2400 #ifdef CONFIG_KEYS
2401
2402 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2403 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2404
2405 /* Populate username and pw fields from keyring if possible */
2406 static int
2407 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2408 {
2409         int rc = 0;
2410         const char *delim, *payload;
2411         char *desc;
2412         ssize_t len;
2413         struct key *key;
2414         struct TCP_Server_Info *server = ses->server;
2415         struct sockaddr_in *sa;
2416         struct sockaddr_in6 *sa6;
2417         const struct user_key_payload *upayload;
2418
2419         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2420         if (!desc)
2421                 return -ENOMEM;
2422
2423         /* try to find an address key first */
2424         switch (server->dstaddr.ss_family) {
2425         case AF_INET:
2426                 sa = (struct sockaddr_in *)&server->dstaddr;
2427                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2428                 break;
2429         case AF_INET6:
2430                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2431                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2432                 break;
2433         default:
2434                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2435                          server->dstaddr.ss_family);
2436                 rc = -EINVAL;
2437                 goto out_err;
2438         }
2439
2440         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2441         key = request_key(&key_type_logon, desc, "");
2442         if (IS_ERR(key)) {
2443                 if (!ses->domainName) {
2444                         cifs_dbg(FYI, "domainName is NULL\n");
2445                         rc = PTR_ERR(key);
2446                         goto out_err;
2447                 }
2448
2449                 /* didn't work, try to find a domain key */
2450                 sprintf(desc, "cifs:d:%s", ses->domainName);
2451                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2452                 key = request_key(&key_type_logon, desc, "");
2453                 if (IS_ERR(key)) {
2454                         rc = PTR_ERR(key);
2455                         goto out_err;
2456                 }
2457         }
2458
2459         down_read(&key->sem);
2460         upayload = user_key_payload_locked(key);
2461         if (IS_ERR_OR_NULL(upayload)) {
2462                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2463                 goto out_key_put;
2464         }
2465
2466         /* find first : in payload */
2467         payload = upayload->data;
2468         delim = strnchr(payload, upayload->datalen, ':');
2469         cifs_dbg(FYI, "payload=%s\n", payload);
2470         if (!delim) {
2471                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2472                          upayload->datalen);
2473                 rc = -EINVAL;
2474                 goto out_key_put;
2475         }
2476
2477         len = delim - payload;
2478         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2479                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2480                          len);
2481                 rc = -EINVAL;
2482                 goto out_key_put;
2483         }
2484
2485         vol->username = kstrndup(payload, len, GFP_KERNEL);
2486         if (!vol->username) {
2487                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2488                          len);
2489                 rc = -ENOMEM;
2490                 goto out_key_put;
2491         }
2492         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2493
2494         len = key->datalen - (len + 1);
2495         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2496                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2497                 rc = -EINVAL;
2498                 kfree(vol->username);
2499                 vol->username = NULL;
2500                 goto out_key_put;
2501         }
2502
2503         ++delim;
2504         vol->password = kstrndup(delim, len, GFP_KERNEL);
2505         if (!vol->password) {
2506                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2507                          len);
2508                 rc = -ENOMEM;
2509                 kfree(vol->username);
2510                 vol->username = NULL;
2511                 goto out_key_put;
2512         }
2513
2514 out_key_put:
2515         up_read(&key->sem);
2516         key_put(key);
2517 out_err:
2518         kfree(desc);
2519         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2520         return rc;
2521 }
2522 #else /* ! CONFIG_KEYS */
2523 static inline int
2524 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2525                    struct cifs_ses *ses __attribute__((unused)))
2526 {
2527         return -ENOSYS;
2528 }
2529 #endif /* CONFIG_KEYS */
2530
2531 static struct cifs_ses *
2532 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2533 {
2534         int rc = -ENOMEM;
2535         unsigned int xid;
2536         struct cifs_ses *ses;
2537         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2538         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2539
2540         xid = get_xid();
2541
2542         ses = cifs_find_smb_ses(server, volume_info);
2543         if (ses) {
2544                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2545                          ses->status);
2546
2547                 mutex_lock(&ses->session_mutex);
2548                 rc = cifs_negotiate_protocol(xid, ses);
2549                 if (rc) {
2550                         mutex_unlock(&ses->session_mutex);
2551                         /* problem -- put our ses reference */
2552                         cifs_put_smb_ses(ses);
2553                         free_xid(xid);
2554                         return ERR_PTR(rc);
2555                 }
2556                 if (ses->need_reconnect) {
2557                         cifs_dbg(FYI, "Session needs reconnect\n");
2558                         rc = cifs_setup_session(xid, ses,
2559                                                 volume_info->local_nls);
2560                         if (rc) {
2561                                 mutex_unlock(&ses->session_mutex);
2562                                 /* problem -- put our reference */
2563                                 cifs_put_smb_ses(ses);
2564                                 free_xid(xid);
2565                                 return ERR_PTR(rc);
2566                         }
2567                 }
2568                 mutex_unlock(&ses->session_mutex);
2569
2570                 /* existing SMB ses has a server reference already */
2571                 cifs_put_tcp_session(server, 0);
2572                 free_xid(xid);
2573                 return ses;
2574         }
2575
2576         cifs_dbg(FYI, "Existing smb sess not found\n");
2577         ses = sesInfoAlloc();
2578         if (ses == NULL)
2579                 goto get_ses_fail;
2580
2581         /* new SMB session uses our server ref */
2582         ses->server = server;
2583         if (server->dstaddr.ss_family == AF_INET6)
2584                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2585         else
2586                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2587
2588         if (volume_info->username) {
2589                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2590                 if (!ses->user_name)
2591                         goto get_ses_fail;
2592         }
2593
2594         /* volume_info->password freed at unmount */
2595         if (volume_info->password) {
2596                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2597                 if (!ses->password)
2598                         goto get_ses_fail;
2599         }
2600         if (volume_info->domainname) {
2601                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2602                 if (!ses->domainName)
2603                         goto get_ses_fail;
2604         }
2605         if (volume_info->domainauto)
2606                 ses->domainAuto = volume_info->domainauto;
2607         ses->cred_uid = volume_info->cred_uid;
2608         ses->linux_uid = volume_info->linux_uid;
2609
2610         ses->sectype = volume_info->sectype;
2611         ses->sign = volume_info->sign;
2612
2613         mutex_lock(&ses->session_mutex);
2614         rc = cifs_negotiate_protocol(xid, ses);
2615         if (!rc)
2616                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2617         mutex_unlock(&ses->session_mutex);
2618         if (rc)
2619                 goto get_ses_fail;
2620
2621         /* success, put it on the list */
2622         spin_lock(&cifs_tcp_ses_lock);
2623         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2624         spin_unlock(&cifs_tcp_ses_lock);
2625
2626         free_xid(xid);
2627         return ses;
2628
2629 get_ses_fail:
2630         sesInfoFree(ses);
2631         free_xid(xid);
2632         return ERR_PTR(rc);
2633 }
2634
2635 static int match_tcon(struct cifs_tcon *tcon, struct smb_vol *volume_info)
2636 {
2637         if (tcon->tidStatus == CifsExiting)
2638                 return 0;
2639         if (strncmp(tcon->treeName, volume_info->UNC, MAX_TREE_SIZE))
2640                 return 0;
2641         if (tcon->seal != volume_info->seal)
2642                 return 0;
2643 #ifdef CONFIG_CIFS_SMB2
2644         if (tcon->snapshot_time != volume_info->snapshot_time)
2645                 return 0;
2646 #endif /* CONFIG_CIFS_SMB2 */
2647         return 1;
2648 }
2649
2650 static struct cifs_tcon *
2651 cifs_find_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2652 {
2653         struct list_head *tmp;
2654         struct cifs_tcon *tcon;
2655
2656         spin_lock(&cifs_tcp_ses_lock);
2657         list_for_each(tmp, &ses->tcon_list) {
2658                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2659                 if (!match_tcon(tcon, volume_info))
2660                         continue;
2661                 ++tcon->tc_count;
2662                 spin_unlock(&cifs_tcp_ses_lock);
2663                 return tcon;
2664         }
2665         spin_unlock(&cifs_tcp_ses_lock);
2666         return NULL;
2667 }
2668
2669 void
2670 cifs_put_tcon(struct cifs_tcon *tcon)
2671 {
2672         unsigned int xid;
2673         struct cifs_ses *ses = tcon->ses;
2674
2675         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2676         spin_lock(&cifs_tcp_ses_lock);
2677         if (--tcon->tc_count > 0) {
2678                 spin_unlock(&cifs_tcp_ses_lock);
2679                 return;
2680         }
2681
2682         list_del_init(&tcon->tcon_list);
2683         spin_unlock(&cifs_tcp_ses_lock);
2684
2685         xid = get_xid();
2686         if (ses->server->ops->tree_disconnect)
2687                 ses->server->ops->tree_disconnect(xid, tcon);
2688         _free_xid(xid);
2689
2690         cifs_fscache_release_super_cookie(tcon);
2691         tconInfoFree(tcon);
2692         cifs_put_smb_ses(ses);
2693 }
2694
2695 static struct cifs_tcon *
2696 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2697 {
2698         int rc, xid;
2699         struct cifs_tcon *tcon;
2700
2701         tcon = cifs_find_tcon(ses, volume_info);
2702         if (tcon) {
2703                 cifs_dbg(FYI, "Found match on UNC path\n");
2704                 /* existing tcon already has a reference */
2705                 cifs_put_smb_ses(ses);
2706                 return tcon;
2707         }
2708
2709         if (!ses->server->ops->tree_connect) {
2710                 rc = -ENOSYS;
2711                 goto out_fail;
2712         }
2713
2714         tcon = tconInfoAlloc();
2715         if (tcon == NULL) {
2716                 rc = -ENOMEM;
2717                 goto out_fail;
2718         }
2719
2720         if (volume_info->snapshot_time) {
2721 #ifdef CONFIG_CIFS_SMB2
2722                 if (ses->server->vals->protocol_id == 0) {
2723                         cifs_dbg(VFS,
2724                              "Use SMB2 or later for snapshot mount option\n");
2725                         rc = -EOPNOTSUPP;
2726                         goto out_fail;
2727                 } else
2728                         tcon->snapshot_time = volume_info->snapshot_time;
2729 #else
2730                 cifs_dbg(VFS, "Snapshot mount option requires SMB2 support\n");
2731                 rc = -EOPNOTSUPP;
2732                 goto out_fail;
2733 #endif /* CONFIG_CIFS_SMB2 */
2734         }
2735
2736         tcon->ses = ses;
2737         if (volume_info->password) {
2738                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2739                 if (!tcon->password) {
2740                         rc = -ENOMEM;
2741                         goto out_fail;
2742                 }
2743         }
2744
2745         /*
2746          * BB Do we need to wrap session_mutex around this TCon call and Unix
2747          * SetFS as we do on SessSetup and reconnect?
2748          */
2749         xid = get_xid();
2750         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2751                                             volume_info->local_nls);
2752         free_xid(xid);
2753         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2754         if (rc)
2755                 goto out_fail;
2756
2757         if (volume_info->nodfs) {
2758                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2759                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2760         }
2761         tcon->use_persistent = false;
2762         /* check if SMB2 or later, CIFS does not support persistent handles */
2763         if (volume_info->persistent) {
2764                 if (ses->server->vals->protocol_id == 0) {
2765                         cifs_dbg(VFS,
2766                              "SMB3 or later required for persistent handles\n");
2767                         rc = -EOPNOTSUPP;
2768                         goto out_fail;
2769 #ifdef CONFIG_CIFS_SMB2
2770                 } else if (ses->server->capabilities &
2771                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2772                         tcon->use_persistent = true;
2773                 else /* persistent handles requested but not supported */ {
2774                         cifs_dbg(VFS,
2775                                 "Persistent handles not supported on share\n");
2776                         rc = -EOPNOTSUPP;
2777                         goto out_fail;
2778 #endif /* CONFIG_CIFS_SMB2 */
2779                 }
2780 #ifdef CONFIG_CIFS_SMB2
2781         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2782              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2783              && (volume_info->nopersistent == false)) {
2784                 cifs_dbg(FYI, "enabling persistent handles\n");
2785                 tcon->use_persistent = true;
2786 #endif /* CONFIG_CIFS_SMB2 */
2787         } else if (volume_info->resilient) {
2788                 if (ses->server->vals->protocol_id == 0) {
2789                         cifs_dbg(VFS,
2790                              "SMB2.1 or later required for resilient handles\n");
2791                         rc = -EOPNOTSUPP;
2792                         goto out_fail;
2793                 }
2794                 tcon->use_resilient = true;
2795         }
2796
2797         if (volume_info->seal) {
2798                 if (ses->server->vals->protocol_id == 0) {
2799                         cifs_dbg(VFS,
2800                                  "SMB3 or later required for encryption\n");
2801                         rc = -EOPNOTSUPP;
2802                         goto out_fail;
2803 #ifdef CONFIG_CIFS_SMB2
2804                 } else if (tcon->ses->server->capabilities &
2805                                         SMB2_GLOBAL_CAP_ENCRYPTION)
2806                         tcon->seal = true;
2807                 else {
2808                         cifs_dbg(VFS, "Encryption is not supported on share\n");
2809                         rc = -EOPNOTSUPP;
2810                         goto out_fail;
2811 #endif /* CONFIG_CIFS_SMB2 */
2812                 }
2813         }
2814
2815         /*
2816          * We can have only one retry value for a connection to a share so for
2817          * resources mounted more than once to the same server share the last
2818          * value passed in for the retry flag is used.
2819          */
2820         tcon->retry = volume_info->retry;
2821         tcon->nocase = volume_info->nocase;
2822         tcon->local_lease = volume_info->local_lease;
2823         INIT_LIST_HEAD(&tcon->pending_opens);
2824
2825         spin_lock(&cifs_tcp_ses_lock);
2826         list_add(&tcon->tcon_list, &ses->tcon_list);
2827         spin_unlock(&cifs_tcp_ses_lock);
2828
2829         cifs_fscache_get_super_cookie(tcon);
2830
2831         return tcon;
2832
2833 out_fail:
2834         tconInfoFree(tcon);
2835         return ERR_PTR(rc);
2836 }
2837
2838 void
2839 cifs_put_tlink(struct tcon_link *tlink)
2840 {
2841         if (!tlink || IS_ERR(tlink))
2842                 return;
2843
2844         if (!atomic_dec_and_test(&tlink->tl_count) ||
2845             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2846                 tlink->tl_time = jiffies;
2847                 return;
2848         }
2849
2850         if (!IS_ERR(tlink_tcon(tlink)))
2851                 cifs_put_tcon(tlink_tcon(tlink));
2852         kfree(tlink);
2853         return;
2854 }
2855
2856 static inline struct tcon_link *
2857 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2858 {
2859         return cifs_sb->master_tlink;
2860 }
2861
2862 static int
2863 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2864 {
2865         struct cifs_sb_info *old = CIFS_SB(sb);
2866         struct cifs_sb_info *new = mnt_data->cifs_sb;
2867
2868         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2869                 return 0;
2870
2871         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2872             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2873                 return 0;
2874
2875         /*
2876          * We want to share sb only if we don't specify an r/wsize or
2877          * specified r/wsize is greater than or equal to existing one.
2878          */
2879         if (new->wsize && new->wsize < old->wsize)
2880                 return 0;
2881
2882         if (new->rsize && new->rsize < old->rsize)
2883                 return 0;
2884
2885         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2886                 return 0;
2887
2888         if (old->mnt_file_mode != new->mnt_file_mode ||
2889             old->mnt_dir_mode != new->mnt_dir_mode)
2890                 return 0;
2891
2892         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2893                 return 0;
2894
2895         if (old->actimeo != new->actimeo)
2896                 return 0;
2897
2898         return 1;
2899 }
2900
2901 static int
2902 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2903 {
2904         struct cifs_sb_info *old = CIFS_SB(sb);
2905         struct cifs_sb_info *new = mnt_data->cifs_sb;
2906
2907         if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2908                 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2909                         return 0;
2910                 /* The prepath should be null terminated strings */
2911                 if (strcmp(new->prepath, old->prepath))
2912                         return 0;
2913
2914                 return 1;
2915         }
2916         return 0;
2917 }
2918
2919 int
2920 cifs_match_super(struct super_block *sb, void *data)
2921 {
2922         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2923         struct smb_vol *volume_info;
2924         struct cifs_sb_info *cifs_sb;
2925         struct TCP_Server_Info *tcp_srv;
2926         struct cifs_ses *ses;
2927         struct cifs_tcon *tcon;
2928         struct tcon_link *tlink;
2929         int rc = 0;
2930
2931         spin_lock(&cifs_tcp_ses_lock);
2932         cifs_sb = CIFS_SB(sb);
2933         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2934         if (IS_ERR(tlink)) {
2935                 spin_unlock(&cifs_tcp_ses_lock);
2936                 return rc;
2937         }
2938         tcon = tlink_tcon(tlink);
2939         ses = tcon->ses;
2940         tcp_srv = ses->server;
2941
2942         volume_info = mnt_data->vol;
2943
2944         if (!match_server(tcp_srv, volume_info) ||
2945             !match_session(ses, volume_info) ||
2946             !match_tcon(tcon, volume_info) ||
2947             !match_prepath(sb, mnt_data)) {
2948                 rc = 0;
2949                 goto out;
2950         }
2951
2952         rc = compare_mount_options(sb, mnt_data);
2953 out:
2954         spin_unlock(&cifs_tcp_ses_lock);
2955         cifs_put_tlink(tlink);
2956         return rc;
2957 }
2958
2959 int
2960 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2961              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2962              struct dfs_info3_param **referrals, int remap)
2963 {
2964         char *temp_unc;
2965         int rc = 0;
2966
2967         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2968                 return -ENOSYS;
2969
2970         *num_referrals = 0;
2971         *referrals = NULL;
2972
2973         if (ses->ipc_tid == 0) {
2974                 temp_unc = kmalloc(2 /* for slashes */ +
2975                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2976                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2977                 if (temp_unc == NULL)
2978                         return -ENOMEM;
2979                 temp_unc[0] = '\\';
2980                 temp_unc[1] = '\\';
2981                 strcpy(temp_unc + 2, ses->serverName);
2982                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2983                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2984                                                     nls_codepage);
2985                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2986                 kfree(temp_unc);
2987         }
2988         if (rc == 0)
2989                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2990                                                      referrals, num_referrals,
2991                                                      nls_codepage, remap);
2992         /*
2993          * BB - map targetUNCs to dfs_info3 structures, here or in
2994          * ses->server->ops->get_dfs_refer.
2995          */
2996
2997         return rc;
2998 }
2999
3000 #ifdef CONFIG_DEBUG_LOCK_ALLOC
3001 static struct lock_class_key cifs_key[2];
3002 static struct lock_class_key cifs_slock_key[2];
3003
3004 static inline void
3005 cifs_reclassify_socket4(struct socket *sock)
3006 {
3007         struct sock *sk = sock->sk;
3008         BUG_ON(!sock_allow_reclassification(sk));
3009         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
3010                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
3011 }
3012
3013 static inline void
3014 cifs_reclassify_socket6(struct socket *sock)
3015 {
3016         struct sock *sk = sock->sk;
3017         BUG_ON(!sock_allow_reclassification(sk));
3018         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
3019                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
3020 }
3021 #else
3022 static inline void
3023 cifs_reclassify_socket4(struct socket *sock)
3024 {
3025 }
3026
3027 static inline void
3028 cifs_reclassify_socket6(struct socket *sock)
3029 {
3030 }
3031 #endif
3032
3033 /* See RFC1001 section 14 on representation of Netbios names */
3034 static void rfc1002mangle(char *target, char *source, unsigned int length)
3035 {
3036         unsigned int i, j;
3037
3038         for (i = 0, j = 0; i < (length); i++) {
3039                 /* mask a nibble at a time and encode */
3040                 target[j] = 'A' + (0x0F & (source[i] >> 4));
3041                 target[j+1] = 'A' + (0x0F & source[i]);
3042                 j += 2;
3043         }
3044
3045 }
3046
3047 static int
3048 bind_socket(struct TCP_Server_Info *server)
3049 {
3050         int rc = 0;
3051         if (server->srcaddr.ss_family != AF_UNSPEC) {
3052                 /* Bind to the specified local IP address */
3053                 struct socket *socket = server->ssocket;
3054                 rc = socket->ops->bind(socket,
3055                                        (struct sockaddr *) &server->srcaddr,
3056                                        sizeof(server->srcaddr));
3057                 if (rc < 0) {
3058                         struct sockaddr_in *saddr4;
3059                         struct sockaddr_in6 *saddr6;
3060                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
3061                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3062                         if (saddr6->sin6_family == AF_INET6)
3063                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
3064                                          &saddr6->sin6_addr, rc);
3065                         else
3066                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
3067                                          &saddr4->sin_addr.s_addr, rc);
3068                 }
3069         }
3070         return rc;
3071 }
3072
3073 static int
3074 ip_rfc1001_connect(struct TCP_Server_Info *server)
3075 {
3076         int rc = 0;
3077         /*
3078          * some servers require RFC1001 sessinit before sending
3079          * negprot - BB check reconnection in case where second
3080          * sessinit is sent but no second negprot
3081          */
3082         struct rfc1002_session_packet *ses_init_buf;
3083         struct smb_hdr *smb_buf;
3084         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3085                                GFP_KERNEL);
3086         if (ses_init_buf) {
3087                 ses_init_buf->trailer.session_req.called_len = 32;
3088
3089                 if (server->server_RFC1001_name[0] != 0)
3090                         rfc1002mangle(ses_init_buf->trailer.
3091                                       session_req.called_name,
3092                                       server->server_RFC1001_name,
3093                                       RFC1001_NAME_LEN_WITH_NULL);
3094                 else
3095                         rfc1002mangle(ses_init_buf->trailer.
3096                                       session_req.called_name,
3097                                       DEFAULT_CIFS_CALLED_NAME,
3098                                       RFC1001_NAME_LEN_WITH_NULL);
3099
3100                 ses_init_buf->trailer.session_req.calling_len = 32;
3101
3102                 /*
3103                  * calling name ends in null (byte 16) from old smb
3104                  * convention.
3105                  */
3106                 if (server->workstation_RFC1001_name[0] != 0)
3107                         rfc1002mangle(ses_init_buf->trailer.
3108                                       session_req.calling_name,
3109                                       server->workstation_RFC1001_name,
3110                                       RFC1001_NAME_LEN_WITH_NULL);
3111                 else
3112                         rfc1002mangle(ses_init_buf->trailer.
3113                                       session_req.calling_name,
3114                                       "LINUX_CIFS_CLNT",
3115                                       RFC1001_NAME_LEN_WITH_NULL);
3116
3117                 ses_init_buf->trailer.session_req.scope1 = 0;
3118                 ses_init_buf->trailer.session_req.scope2 = 0;
3119                 smb_buf = (struct smb_hdr *)ses_init_buf;
3120
3121                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3122                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3123                 rc = smb_send(server, smb_buf, 0x44);
3124                 kfree(ses_init_buf);
3125                 /*
3126                  * RFC1001 layer in at least one server
3127                  * requires very short break before negprot
3128                  * presumably because not expecting negprot
3129                  * to follow so fast.  This is a simple
3130                  * solution that works without
3131                  * complicating the code and causes no
3132                  * significant slowing down on mount
3133                  * for everyone else
3134                  */
3135                 usleep_range(1000, 2000);
3136         }
3137         /*
3138          * else the negprot may still work without this
3139          * even though malloc failed
3140          */
3141
3142         return rc;
3143 }
3144
3145 static int
3146 generic_ip_connect(struct TCP_Server_Info *server)
3147 {
3148         int rc = 0;
3149         __be16 sport;
3150         int slen, sfamily;
3151         struct socket *socket = server->ssocket;
3152         struct sockaddr *saddr;
3153
3154         saddr = (struct sockaddr *) &server->dstaddr;
3155
3156         if (server->dstaddr.ss_family == AF_INET6) {
3157                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3158                 slen = sizeof(struct sockaddr_in6);
3159                 sfamily = AF_INET6;
3160         } else {
3161                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3162                 slen = sizeof(struct sockaddr_in);
3163                 sfamily = AF_INET;
3164         }
3165
3166         if (socket == NULL) {
3167                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3168                                    IPPROTO_TCP, &socket, 1);
3169                 if (rc < 0) {
3170                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3171                         server->ssocket = NULL;
3172                         return rc;
3173                 }
3174
3175                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3176                 cifs_dbg(FYI, "Socket created\n");
3177                 server->ssocket = socket;
3178                 socket->sk->sk_allocation = GFP_NOFS;
3179                 if (sfamily == AF_INET6)
3180                         cifs_reclassify_socket6(socket);
3181                 else
3182                         cifs_reclassify_socket4(socket);
3183         }
3184
3185         rc = bind_socket(server);
3186         if (rc < 0)
3187                 return rc;
3188
3189         /*
3190          * Eventually check for other socket options to change from
3191          * the default. sock_setsockopt not used because it expects
3192          * user space buffer
3193          */
3194         socket->sk->sk_rcvtimeo = 7 * HZ;
3195         socket->sk->sk_sndtimeo = 5 * HZ;
3196
3197         /* make the bufsizes depend on wsize/rsize and max requests */
3198         if (server->noautotune) {
3199                 if (socket->sk->sk_sndbuf < (200 * 1024))
3200                         socket->sk->sk_sndbuf = 200 * 1024;
3201                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3202                         socket->sk->sk_rcvbuf = 140 * 1024;
3203         }
3204
3205         if (server->tcp_nodelay) {
3206                 int val = 1;
3207                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3208                                 (char *)&val, sizeof(val));
3209                 if (rc)
3210                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3211                                  rc);
3212         }
3213
3214         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3215                  socket->sk->sk_sndbuf,
3216                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3217
3218         rc = socket->ops->connect(socket, saddr, slen, 0);
3219         if (rc < 0) {
3220                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3221                 sock_release(socket);
3222                 server->ssocket = NULL;
3223                 return rc;
3224         }
3225
3226         if (sport == htons(RFC1001_PORT))
3227                 rc = ip_rfc1001_connect(server);
3228
3229         return rc;
3230 }
3231
3232 static int
3233 ip_connect(struct TCP_Server_Info *server)
3234 {
3235         __be16 *sport;
3236         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3237         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3238
3239         if (server->dstaddr.ss_family == AF_INET6)
3240                 sport = &addr6->sin6_port;
3241         else
3242                 sport = &addr->sin_port;
3243
3244         if (*sport == 0) {
3245                 int rc;
3246
3247                 /* try with 445 port at first */
3248                 *sport = htons(CIFS_PORT);
3249
3250                 rc = generic_ip_connect(server);
3251                 if (rc >= 0)
3252                         return rc;
3253
3254                 /* if it failed, try with 139 port */
3255                 *sport = htons(RFC1001_PORT);
3256         }
3257
3258         return generic_ip_connect(server);
3259 }
3260
3261 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3262                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3263 {
3264         /* if we are reconnecting then should we check to see if
3265          * any requested capabilities changed locally e.g. via
3266          * remount but we can not do much about it here
3267          * if they have (even if we could detect it by the following)
3268          * Perhaps we could add a backpointer to array of sb from tcon
3269          * or if we change to make all sb to same share the same
3270          * sb as NFS - then we only have one backpointer to sb.
3271          * What if we wanted to mount the server share twice once with
3272          * and once without posixacls or posix paths? */
3273         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3274
3275         if (vol_info && vol_info->no_linux_ext) {
3276                 tcon->fsUnixInfo.Capability = 0;
3277                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3278                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3279                 return;
3280         } else if (vol_info)
3281                 tcon->unix_ext = 1; /* Unix Extensions supported */
3282
3283         if (tcon->unix_ext == 0) {
3284                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3285                 return;
3286         }
3287
3288         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3289                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3290                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3291                 /* check for reconnect case in which we do not
3292                    want to change the mount behavior if we can avoid it */
3293                 if (vol_info == NULL) {
3294                         /* turn off POSIX ACL and PATHNAMES if not set
3295                            originally at mount time */
3296                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3297                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3298                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3299                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3300                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3301                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3302                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3303                                 cifs_dbg(VFS, "possible reconnect error\n");
3304                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3305                         }
3306                 }
3307
3308                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3309                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3310
3311                 cap &= CIFS_UNIX_CAP_MASK;
3312                 if (vol_info && vol_info->no_psx_acl)
3313                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3314                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3315                         cifs_dbg(FYI, "negotiated posix acl support\n");
3316                         if (cifs_sb)
3317                                 cifs_sb->mnt_cifs_flags |=
3318                                         CIFS_MOUNT_POSIXACL;
3319                 }
3320
3321                 if (vol_info && vol_info->posix_paths == 0)
3322                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3323                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3324                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3325                         if (cifs_sb)
3326                                 cifs_sb->mnt_cifs_flags |=
3327                                         CIFS_MOUNT_POSIX_PATHS;
3328                 }
3329
3330                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3331 #ifdef CONFIG_CIFS_DEBUG2
3332                 if (cap & CIFS_UNIX_FCNTL_CAP)
3333                         cifs_dbg(FYI, "FCNTL cap\n");
3334                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3335                         cifs_dbg(FYI, "EXTATTR cap\n");
3336                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3337                         cifs_dbg(FYI, "POSIX path cap\n");
3338                 if (cap & CIFS_UNIX_XATTR_CAP)
3339                         cifs_dbg(FYI, "XATTR cap\n");
3340                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3341                         cifs_dbg(FYI, "POSIX ACL cap\n");
3342                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3343                         cifs_dbg(FYI, "very large read cap\n");
3344                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3345                         cifs_dbg(FYI, "very large write cap\n");
3346                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3347                         cifs_dbg(FYI, "transport encryption cap\n");
3348                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3349                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3350 #endif /* CIFS_DEBUG2 */
3351                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3352                         if (vol_info == NULL) {
3353                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3354                         } else
3355                                 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");
3356
3357                 }
3358         }
3359 }
3360
3361 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3362                         struct cifs_sb_info *cifs_sb)
3363 {
3364         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3365
3366         spin_lock_init(&cifs_sb->tlink_tree_lock);
3367         cifs_sb->tlink_tree = RB_ROOT;
3368
3369         /*
3370          * Temporarily set r/wsize for matching superblock. If we end up using
3371          * new sb then client will later negotiate it downward if needed.
3372          */
3373         cifs_sb->rsize = pvolume_info->rsize;
3374         cifs_sb->wsize = pvolume_info->wsize;
3375
3376         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3377         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3378         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3379         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3380         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3381                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3382
3383         cifs_sb->actimeo = pvolume_info->actimeo;
3384         cifs_sb->local_nls = pvolume_info->local_nls;
3385
3386         if (pvolume_info->noperm)
3387                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3388         if (pvolume_info->setuids)
3389                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3390         if (pvolume_info->setuidfromacl)
3391                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UID_FROM_ACL;
3392         if (pvolume_info->server_ino)
3393                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3394         if (pvolume_info->remap)
3395                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3396         if (pvolume_info->sfu_remap)
3397                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3398         if (pvolume_info->no_xattr)
3399                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3400         if (pvolume_info->sfu_emul)
3401                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3402         if (pvolume_info->nobrl)
3403                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3404         if (pvolume_info->nostrictsync)
3405                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3406         if (pvolume_info->mand_lock)
3407                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3408         if (pvolume_info->rwpidforward)
3409                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3410         if (pvolume_info->cifs_acl)
3411                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3412         if (pvolume_info->backupuid_specified) {
3413                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3414                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3415         }
3416         if (pvolume_info->backupgid_specified) {
3417                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3418                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3419         }
3420         if (pvolume_info->override_uid)
3421                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3422         if (pvolume_info->override_gid)
3423                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3424         if (pvolume_info->dynperm)
3425                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3426         if (pvolume_info->fsc)
3427                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3428         if (pvolume_info->multiuser)
3429                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3430                                             CIFS_MOUNT_NO_PERM);
3431         if (pvolume_info->strict_io)
3432                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3433         if (pvolume_info->direct_io) {
3434                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3435                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3436         }
3437         if (pvolume_info->mfsymlinks) {
3438                 if (pvolume_info->sfu_emul) {
3439                         /*
3440                          * Our SFU ("Services for Unix" emulation does not allow
3441                          * creating symlinks but does allow reading existing SFU
3442                          * symlinks (it does allow both creating and reading SFU
3443                          * style mknod and FIFOs though). When "mfsymlinks" and
3444                          * "sfu" are both enabled at the same time, it allows
3445                          * reading both types of symlinks, but will only create
3446                          * them with mfsymlinks format. This allows better
3447                          * Apple compatibility (probably better for Samba too)
3448                          * while still recognizing old Windows style symlinks.
3449                          */
3450                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3451                 }
3452                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3453         }
3454
3455         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3456                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3457
3458         if (pvolume_info->prepath) {
3459                 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3460                 if (cifs_sb->prepath == NULL)
3461                         return -ENOMEM;
3462         }
3463
3464         return 0;
3465 }
3466
3467 static void
3468 cleanup_volume_info_contents(struct smb_vol *volume_info)
3469 {
3470         kfree(volume_info->username);
3471         kzfree(volume_info->password);
3472         kfree(volume_info->UNC);
3473         kfree(volume_info->domainname);
3474         kfree(volume_info->iocharset);
3475         kfree(volume_info->prepath);
3476 }
3477
3478 void
3479 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3480 {
3481         if (!volume_info)
3482                 return;
3483         cleanup_volume_info_contents(volume_info);
3484         kfree(volume_info);
3485 }
3486
3487
3488 #ifdef CONFIG_CIFS_DFS_UPCALL
3489 /*
3490  * cifs_build_path_to_root returns full path to root when we do not have an
3491  * exiting connection (tcon)
3492  */
3493 static char *
3494 build_unc_path_to_root(const struct smb_vol *vol,
3495                 const struct cifs_sb_info *cifs_sb)
3496 {
3497         char *full_path, *pos;
3498         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3499         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3500
3501         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3502         if (full_path == NULL)
3503                 return ERR_PTR(-ENOMEM);
3504
3505         strncpy(full_path, vol->UNC, unc_len);
3506         pos = full_path + unc_len;
3507
3508         if (pplen) {
3509                 *pos = CIFS_DIR_SEP(cifs_sb);
3510                 strncpy(pos + 1, vol->prepath, pplen);
3511                 pos += pplen;
3512         }
3513
3514         *pos = '\0'; /* add trailing null */
3515         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3516         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3517         return full_path;
3518 }
3519
3520 /*
3521  * Perform a dfs referral query for a share and (optionally) prefix
3522  *
3523  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3524  * to a string containing updated options for the submount.  Otherwise it
3525  * will be left untouched.
3526  *
3527  * Returns the rc from get_dfs_path to the caller, which can be used to
3528  * determine whether there were referrals.
3529  */
3530 static int
3531 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3532                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3533                     int check_prefix)
3534 {
3535         int rc;
3536         unsigned int num_referrals = 0;
3537         struct dfs_info3_param *referrals = NULL;
3538         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3539
3540         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3541         if (IS_ERR(full_path))
3542                 return PTR_ERR(full_path);
3543
3544         /* For DFS paths, skip the first '\' of the UNC */
3545         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3546
3547         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3548                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3549
3550         if (!rc && num_referrals > 0) {
3551                 char *fake_devname = NULL;
3552
3553                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3554                                                    full_path + 1, referrals,
3555                                                    &fake_devname);
3556
3557                 free_dfs_info_array(referrals, num_referrals);
3558
3559                 if (IS_ERR(mdata)) {
3560                         rc = PTR_ERR(mdata);
3561                         mdata = NULL;
3562                 } else {
3563                         cleanup_volume_info_contents(volume_info);
3564                         rc = cifs_setup_volume_info(volume_info, mdata,
3565                                                         fake_devname);
3566                 }
3567                 kfree(fake_devname);
3568                 kfree(cifs_sb->mountdata);
3569                 cifs_sb->mountdata = mdata;
3570         }
3571         kfree(full_path);
3572         return rc;
3573 }
3574 #endif
3575
3576 static int
3577 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3578                         const char *devname)
3579 {
3580         int rc = 0;
3581
3582         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3583                 return -EINVAL;
3584
3585         if (volume_info->nullauth) {
3586                 cifs_dbg(FYI, "Anonymous login\n");
3587                 kfree(volume_info->username);
3588                 volume_info->username = NULL;
3589         } else if (volume_info->username) {
3590                 /* BB fixme parse for domain name here */
3591                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3592         } else {
3593                 cifs_dbg(VFS, "No username specified\n");
3594         /* In userspace mount helper we can get user name from alternate
3595            locations such as env variables and files on disk */
3596                 return -EINVAL;
3597         }
3598
3599         /* this is needed for ASCII cp to Unicode converts */
3600         if (volume_info->iocharset == NULL) {
3601                 /* load_nls_default cannot return null */
3602                 volume_info->local_nls = load_nls_default();
3603         } else {
3604                 volume_info->local_nls = load_nls(volume_info->iocharset);
3605                 if (volume_info->local_nls == NULL) {
3606                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3607                                  volume_info->iocharset);
3608                         return -ELIBACC;
3609                 }
3610         }
3611
3612         return rc;
3613 }
3614
3615 struct smb_vol *
3616 cifs_get_volume_info(char *mount_data, const char *devname)
3617 {
3618         int rc;
3619         struct smb_vol *volume_info;
3620
3621         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3622         if (!volume_info)
3623                 return ERR_PTR(-ENOMEM);
3624
3625         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3626         if (rc) {
3627                 cifs_cleanup_volume_info(volume_info);
3628                 volume_info = ERR_PTR(rc);
3629         }
3630
3631         return volume_info;
3632 }
3633
3634 static int
3635 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3636                                         unsigned int xid,
3637                                         struct cifs_tcon *tcon,
3638                                         struct cifs_sb_info *cifs_sb,
3639                                         char *full_path)
3640 {
3641         int rc;
3642         char *s;
3643         char sep, tmp;
3644
3645         sep = CIFS_DIR_SEP(cifs_sb);
3646         s = full_path;
3647
3648         rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3649         while (rc == 0) {
3650                 /* skip separators */
3651                 while (*s == sep)
3652                         s++;
3653                 if (!*s)
3654                         break;
3655                 /* next separator */
3656                 while (*s && *s != sep)
3657                         s++;
3658
3659                 /*
3660                  * temporarily null-terminate the path at the end of
3661                  * the current component
3662                  */
3663                 tmp = *s;
3664                 *s = 0;
3665                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3666                                                      full_path);
3667                 *s = tmp;
3668         }
3669         return rc;
3670 }
3671
3672 int
3673 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3674 {
3675         int rc;
3676         unsigned int xid;
3677         struct cifs_ses *ses;
3678         struct cifs_tcon *tcon;
3679         struct TCP_Server_Info *server;
3680         char   *full_path;
3681         struct tcon_link *tlink;
3682 #ifdef CONFIG_CIFS_DFS_UPCALL
3683         int referral_walks_count = 0;
3684 #endif
3685
3686         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3687         if (rc)
3688                 return rc;
3689
3690 #ifdef CONFIG_CIFS_DFS_UPCALL
3691 try_mount_again:
3692         /* cleanup activities if we're chasing a referral */
3693         if (referral_walks_count) {
3694                 if (tcon)
3695                         cifs_put_tcon(tcon);
3696                 else if (ses)
3697                         cifs_put_smb_ses(ses);
3698
3699                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3700
3701                 free_xid(xid);
3702         }
3703 #endif
3704         rc = 0;
3705         tcon = NULL;
3706         ses = NULL;
3707         server = NULL;
3708         full_path = NULL;
3709         tlink = NULL;
3710
3711         xid = get_xid();
3712
3713         /* get a reference to a tcp session */
3714         server = cifs_get_tcp_session(volume_info);
3715         if (IS_ERR(server)) {
3716                 rc = PTR_ERR(server);
3717                 bdi_destroy(&cifs_sb->bdi);
3718                 goto out;
3719         }
3720         if ((volume_info->max_credits < 20) ||
3721              (volume_info->max_credits > 60000))
3722                 server->max_credits = SMB2_MAX_CREDITS_AVAILABLE;
3723         else
3724                 server->max_credits = volume_info->max_credits;
3725         /* get a reference to a SMB session */
3726         ses = cifs_get_smb_ses(server, volume_info);
3727         if (IS_ERR(ses)) {
3728                 rc = PTR_ERR(ses);
3729                 ses = NULL;
3730                 goto mount_fail_check;
3731         }
3732
3733 #ifdef CONFIG_CIFS_SMB2
3734         if ((volume_info->persistent == true) && ((ses->server->capabilities &
3735                 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3736                 cifs_dbg(VFS, "persistent handles not supported by server\n");
3737                 rc = -EOPNOTSUPP;
3738                 goto mount_fail_check;
3739         }
3740 #endif /* CONFIG_CIFS_SMB2*/
3741
3742         /* search for existing tcon to this server share */
3743         tcon = cifs_get_tcon(ses, volume_info);
3744         if (IS_ERR(tcon)) {
3745                 rc = PTR_ERR(tcon);
3746                 tcon = NULL;
3747                 goto remote_path_check;
3748         }
3749
3750         /* tell server which Unix caps we support */
3751         if (cap_unix(tcon->ses)) {
3752                 /* reset of caps checks mount to see if unix extensions
3753                    disabled for just this mount */
3754                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3755                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3756                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3757                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3758                         rc = -EACCES;
3759                         goto mount_fail_check;
3760                 }
3761         } else
3762                 tcon->unix_ext = 0; /* server does not support them */
3763
3764         /* do not care if a following call succeed - informational */
3765         if (!tcon->ipc && server->ops->qfs_tcon)
3766                 server->ops->qfs_tcon(xid, tcon);
3767
3768         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3769         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3770
3771         /* tune readahead according to rsize */
3772         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3773
3774 remote_path_check:
3775 #ifdef CONFIG_CIFS_DFS_UPCALL
3776         /*
3777          * Perform an unconditional check for whether there are DFS
3778          * referrals for this path without prefix, to provide support
3779          * for DFS referrals from w2k8 servers which don't seem to respond
3780          * with PATH_NOT_COVERED to requests that include the prefix.
3781          * Chase the referral if found, otherwise continue normally.
3782          */
3783         if (referral_walks_count == 0) {
3784                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3785                                                 false);
3786                 if (!refrc) {
3787                         referral_walks_count++;
3788                         goto try_mount_again;
3789                 }
3790         }
3791 #endif
3792
3793         /* check if a whole path is not remote */
3794         if (!rc && tcon) {
3795                 if (!server->ops->is_path_accessible) {
3796                         rc = -ENOSYS;
3797                         goto mount_fail_check;
3798                 }
3799                 /*
3800                  * cifs_build_path_to_root works only when we have a valid tcon
3801                  */
3802                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon,
3803                                         tcon->Flags & SMB_SHARE_IS_IN_DFS);
3804                 if (full_path == NULL) {
3805                         rc = -ENOMEM;
3806                         goto mount_fail_check;
3807                 }
3808                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3809                                                      full_path);
3810                 if (rc != 0 && rc != -EREMOTE) {
3811                         kfree(full_path);
3812                         goto mount_fail_check;
3813                 }
3814
3815                 if (rc != -EREMOTE) {
3816                         rc = cifs_are_all_path_components_accessible(server,
3817                                                              xid, tcon, cifs_sb,
3818                                                              full_path);
3819                         if (rc != 0) {
3820                                 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3821                                          "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3822                                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3823                                 rc = 0;
3824                         }
3825                 }
3826                 kfree(full_path);
3827         }
3828
3829         /* get referral if needed */
3830         if (rc == -EREMOTE) {
3831 #ifdef CONFIG_CIFS_DFS_UPCALL
3832                 if (referral_walks_count > MAX_NESTED_LINKS) {
3833                         /*
3834                          * BB: when we implement proper loop detection,
3835                          *     we will remove this check. But now we need it
3836                          *     to prevent an indefinite loop if 'DFS tree' is
3837                          *     misconfigured (i.e. has loops).
3838                          */
3839                         rc = -ELOOP;
3840                         goto mount_fail_check;
3841                 }
3842
3843                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3844
3845                 if (!rc) {
3846                         referral_walks_count++;
3847                         goto try_mount_again;
3848                 }
3849                 goto mount_fail_check;
3850 #else /* No DFS support, return error on mount */
3851                 rc = -EOPNOTSUPP;
3852 #endif
3853         }
3854
3855         if (rc)
3856                 goto mount_fail_check;
3857
3858         /* now, hang the tcon off of the superblock */
3859         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3860         if (tlink == NULL) {
3861                 rc = -ENOMEM;
3862                 goto mount_fail_check;
3863         }
3864
3865         tlink->tl_uid = ses->linux_uid;
3866         tlink->tl_tcon = tcon;
3867         tlink->tl_time = jiffies;
3868         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3869         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3870
3871         cifs_sb->master_tlink = tlink;
3872         spin_lock(&cifs_sb->tlink_tree_lock);
3873         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3874         spin_unlock(&cifs_sb->tlink_tree_lock);
3875
3876         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3877                                 TLINK_IDLE_EXPIRE);
3878
3879 mount_fail_check:
3880         /* on error free sesinfo and tcon struct if needed */
3881         if (rc) {
3882                 /* If find_unc succeeded then rc == 0 so we can not end */
3883                 /* up accidentally freeing someone elses tcon struct */
3884                 if (tcon)
3885                         cifs_put_tcon(tcon);
3886                 else if (ses)
3887                         cifs_put_smb_ses(ses);
3888                 else
3889                         cifs_put_tcp_session(server, 0);
3890                 bdi_destroy(&cifs_sb->bdi);
3891         }
3892
3893 out:
3894         free_xid(xid);
3895         return rc;
3896 }
3897
3898 /*
3899  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3900  * pointer may be NULL.
3901  */
3902 int
3903 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3904          const char *tree, struct cifs_tcon *tcon,
3905          const struct nls_table *nls_codepage)
3906 {
3907         struct smb_hdr *smb_buffer;
3908         struct smb_hdr *smb_buffer_response;
3909         TCONX_REQ *pSMB;
3910         TCONX_RSP *pSMBr;
3911         unsigned char *bcc_ptr;
3912         int rc = 0;
3913         int length;
3914         __u16 bytes_left, count;
3915
3916         if (ses == NULL)
3917                 return -EIO;
3918
3919         smb_buffer = cifs_buf_get();
3920         if (smb_buffer == NULL)
3921                 return -ENOMEM;
3922
3923         smb_buffer_response = smb_buffer;
3924
3925         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3926                         NULL /*no tid */ , 4 /*wct */ );
3927
3928         smb_buffer->Mid = get_next_mid(ses->server);
3929         smb_buffer->Uid = ses->Suid;
3930         pSMB = (TCONX_REQ *) smb_buffer;
3931         pSMBr = (TCONX_RSP *) smb_buffer_response;
3932
3933         pSMB->AndXCommand = 0xFF;
3934         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3935         bcc_ptr = &pSMB->Password[0];
3936         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3937                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3938                 *bcc_ptr = 0; /* password is null byte */
3939                 bcc_ptr++;              /* skip password */
3940                 /* already aligned so no need to do it below */
3941         } else {
3942                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3943                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3944                    specified as required (when that support is added to
3945                    the vfs in the future) as only NTLM or the much
3946                    weaker LANMAN (which we do not send by default) is accepted
3947                    by Samba (not sure whether other servers allow
3948                    NTLMv2 password here) */
3949 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3950                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3951                     (ses->sectype == LANMAN))
3952                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3953                                          ses->server->sec_mode &
3954                                             SECMODE_PW_ENCRYPT ? true : false,
3955                                          bcc_ptr);
3956                 else
3957 #endif /* CIFS_WEAK_PW_HASH */
3958                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3959                                         bcc_ptr, nls_codepage);
3960                 if (rc) {
3961                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3962                                  __func__, rc);
3963                         cifs_buf_release(smb_buffer);
3964                         return rc;
3965                 }
3966
3967                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3968                 if (ses->capabilities & CAP_UNICODE) {
3969                         /* must align unicode strings */
3970                         *bcc_ptr = 0; /* null byte password */
3971                         bcc_ptr++;
3972                 }
3973         }
3974
3975         if (ses->server->sign)
3976                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3977
3978         if (ses->capabilities & CAP_STATUS32) {
3979                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3980         }
3981         if (ses->capabilities & CAP_DFS) {
3982                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3983         }
3984         if (ses->capabilities & CAP_UNICODE) {
3985                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3986                 length =
3987                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3988                         6 /* max utf8 char length in bytes */ *
3989                         (/* server len*/ + 256 /* share len */), nls_codepage);
3990                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3991                 bcc_ptr += 2;   /* skip trailing null */
3992         } else {                /* ASCII */
3993                 strcpy(bcc_ptr, tree);
3994                 bcc_ptr += strlen(tree) + 1;
3995         }
3996         strcpy(bcc_ptr, "?????");
3997         bcc_ptr += strlen("?????");
3998         bcc_ptr += 1;
3999         count = bcc_ptr - &pSMB->Password[0];
4000         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4001                                         pSMB->hdr.smb_buf_length) + count);
4002         pSMB->ByteCount = cpu_to_le16(count);
4003
4004         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4005                          0);
4006
4007         /* above now done in SendReceive */
4008         if ((rc == 0) && (tcon != NULL)) {
4009                 bool is_unicode;
4010
4011                 tcon->tidStatus = CifsGood;
4012                 tcon->need_reconnect = false;
4013                 tcon->tid = smb_buffer_response->Tid;
4014                 bcc_ptr = pByteArea(smb_buffer_response);
4015                 bytes_left = get_bcc(smb_buffer_response);
4016                 length = strnlen(bcc_ptr, bytes_left - 2);
4017                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4018                         is_unicode = true;
4019                 else
4020                         is_unicode = false;
4021
4022
4023                 /* skip service field (NB: this field is always ASCII) */
4024                 if (length == 3) {
4025                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4026                             (bcc_ptr[2] == 'C')) {
4027                                 cifs_dbg(FYI, "IPC connection\n");
4028                                 tcon->ipc = 1;
4029                         }
4030                 } else if (length == 2) {
4031                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4032                                 /* the most common case */
4033                                 cifs_dbg(FYI, "disk share connection\n");
4034                         }
4035                 }
4036                 bcc_ptr += length + 1;
4037                 bytes_left -= (length + 1);
4038                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
4039
4040                 /* mostly informational -- no need to fail on error here */
4041                 kfree(tcon->nativeFileSystem);
4042                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4043                                                       bytes_left, is_unicode,
4044                                                       nls_codepage);
4045
4046                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
4047
4048                 if ((smb_buffer_response->WordCount == 3) ||
4049                          (smb_buffer_response->WordCount == 7))
4050                         /* field is in same location */
4051                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4052                 else
4053                         tcon->Flags = 0;
4054                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
4055         } else if ((rc == 0) && tcon == NULL) {
4056                 /* all we need to save for IPC$ connection */
4057                 ses->ipc_tid = smb_buffer_response->Tid;
4058         }
4059
4060         cifs_buf_release(smb_buffer);
4061         return rc;
4062 }
4063
4064 static void delayed_free(struct rcu_head *p)
4065 {
4066         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
4067         unload_nls(sbi->local_nls);
4068         kfree(sbi);
4069 }
4070
4071 void
4072 cifs_umount(struct cifs_sb_info *cifs_sb)
4073 {
4074         struct rb_root *root = &cifs_sb->tlink_tree;
4075         struct rb_node *node;
4076         struct tcon_link *tlink;
4077
4078         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4079
4080         spin_lock(&cifs_sb->tlink_tree_lock);
4081         while ((node = rb_first(root))) {
4082                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4083                 cifs_get_tlink(tlink);
4084                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4085                 rb_erase(node, root);
4086
4087                 spin_unlock(&cifs_sb->tlink_tree_lock);
4088                 cifs_put_tlink(tlink);
4089                 spin_lock(&cifs_sb->tlink_tree_lock);
4090         }
4091         spin_unlock(&cifs_sb->tlink_tree_lock);
4092
4093         bdi_destroy(&cifs_sb->bdi);
4094         kfree(cifs_sb->mountdata);
4095         kfree(cifs_sb->prepath);
4096         call_rcu(&cifs_sb->rcu, delayed_free);
4097 }
4098
4099 int
4100 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
4101 {
4102         int rc = 0;
4103         struct TCP_Server_Info *server = ses->server;
4104
4105         if (!server->ops->need_neg || !server->ops->negotiate)
4106                 return -ENOSYS;
4107
4108         /* only send once per connect */
4109         if (!server->ops->need_neg(server))
4110                 return 0;
4111
4112         set_credits(server, 1);
4113
4114         rc = server->ops->negotiate(xid, ses);
4115         if (rc == 0) {
4116                 spin_lock(&GlobalMid_Lock);
4117                 if (server->tcpStatus == CifsNeedNegotiate)
4118                         server->tcpStatus = CifsGood;
4119                 else
4120                         rc = -EHOSTDOWN;
4121                 spin_unlock(&GlobalMid_Lock);
4122         }
4123
4124         return rc;
4125 }
4126
4127 int
4128 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4129                    struct nls_table *nls_info)
4130 {
4131         int rc = -ENOSYS;
4132         struct TCP_Server_Info *server = ses->server;
4133
4134         ses->capabilities = server->capabilities;
4135         if (linuxExtEnabled == 0)
4136                 ses->capabilities &= (~server->vals->cap_unix);
4137
4138         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4139                  server->sec_mode, server->capabilities, server->timeAdj);
4140
4141         if (server->ops->sess_setup)
4142                 rc = server->ops->sess_setup(xid, ses, nls_info);
4143
4144         if (rc)
4145                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4146
4147         return rc;
4148 }
4149
4150 static int
4151 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4152 {
4153         vol->sectype = ses->sectype;
4154
4155         /* krb5 is special, since we don't need username or pw */
4156         if (vol->sectype == Kerberos)
4157                 return 0;
4158
4159         return cifs_set_cifscreds(vol, ses);
4160 }
4161
4162 static struct cifs_tcon *
4163 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4164 {
4165         int rc;
4166         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4167         struct cifs_ses *ses;
4168         struct cifs_tcon *tcon = NULL;
4169         struct smb_vol *vol_info;
4170
4171         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4172         if (vol_info == NULL)
4173                 return ERR_PTR(-ENOMEM);
4174
4175         vol_info->local_nls = cifs_sb->local_nls;
4176         vol_info->linux_uid = fsuid;
4177         vol_info->cred_uid = fsuid;
4178         vol_info->UNC = master_tcon->treeName;
4179         vol_info->retry = master_tcon->retry;
4180         vol_info->nocase = master_tcon->nocase;
4181         vol_info->local_lease = master_tcon->local_lease;
4182         vol_info->no_linux_ext = !master_tcon->unix_ext;
4183         vol_info->sectype = master_tcon->ses->sectype;
4184         vol_info->sign = master_tcon->ses->sign;
4185
4186         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4187         if (rc) {
4188                 tcon = ERR_PTR(rc);
4189                 goto out;
4190         }
4191
4192         /* get a reference for the same TCP session */
4193         spin_lock(&cifs_tcp_ses_lock);
4194         ++master_tcon->ses->server->srv_count;
4195         spin_unlock(&cifs_tcp_ses_lock);
4196
4197         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4198         if (IS_ERR(ses)) {
4199                 tcon = (struct cifs_tcon *)ses;
4200                 cifs_put_tcp_session(master_tcon->ses->server, 0);
4201                 goto out;
4202         }
4203
4204         tcon = cifs_get_tcon(ses, vol_info);
4205         if (IS_ERR(tcon)) {
4206                 cifs_put_smb_ses(ses);
4207                 goto out;
4208         }
4209
4210         if (cap_unix(ses))
4211                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4212 out:
4213         kfree(vol_info->username);
4214         kfree(vol_info->password);
4215         kfree(vol_info);
4216
4217         return tcon;
4218 }
4219
4220 struct cifs_tcon *
4221 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4222 {
4223         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4224 }
4225
4226 /* find and return a tlink with given uid */
4227 static struct tcon_link *
4228 tlink_rb_search(struct rb_root *root, kuid_t uid)
4229 {
4230         struct rb_node *node = root->rb_node;
4231         struct tcon_link *tlink;
4232
4233         while (node) {
4234                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4235
4236                 if (uid_gt(tlink->tl_uid, uid))
4237                         node = node->rb_left;
4238                 else if (uid_lt(tlink->tl_uid, uid))
4239                         node = node->rb_right;
4240                 else
4241                         return tlink;
4242         }
4243         return NULL;
4244 }
4245
4246 /* insert a tcon_link into the tree */
4247 static void
4248 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4249 {
4250         struct rb_node **new = &(root->rb_node), *parent = NULL;
4251         struct tcon_link *tlink;
4252
4253         while (*new) {
4254                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4255                 parent = *new;
4256
4257                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4258                         new = &((*new)->rb_left);
4259                 else
4260                         new = &((*new)->rb_right);
4261         }
4262
4263         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4264         rb_insert_color(&new_tlink->tl_rbnode, root);
4265 }
4266
4267 /*
4268  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4269  * current task.
4270  *
4271  * If the superblock doesn't refer to a multiuser mount, then just return
4272  * the master tcon for the mount.
4273  *
4274  * First, search the rbtree for an existing tcon for this fsuid. If one
4275  * exists, then check to see if it's pending construction. If it is then wait
4276  * for construction to complete. Once it's no longer pending, check to see if
4277  * it failed and either return an error or retry construction, depending on
4278  * the timeout.
4279  *
4280  * If one doesn't exist then insert a new tcon_link struct into the tree and
4281  * try to construct a new one.
4282  */
4283 struct tcon_link *
4284 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4285 {
4286         int ret;
4287         kuid_t fsuid = current_fsuid();
4288         struct tcon_link *tlink, *newtlink;
4289
4290         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4291                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4292
4293         spin_lock(&cifs_sb->tlink_tree_lock);
4294         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4295         if (tlink)
4296                 cifs_get_tlink(tlink);
4297         spin_unlock(&cifs_sb->tlink_tree_lock);
4298
4299         if (tlink == NULL) {
4300                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4301                 if (newtlink == NULL)
4302                         return ERR_PTR(-ENOMEM);
4303                 newtlink->tl_uid = fsuid;
4304                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4305                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4306                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4307                 cifs_get_tlink(newtlink);
4308
4309                 spin_lock(&cifs_sb->tlink_tree_lock);
4310                 /* was one inserted after previous search? */
4311                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4312                 if (tlink) {
4313                         cifs_get_tlink(tlink);
4314                         spin_unlock(&cifs_sb->tlink_tree_lock);
4315                         kfree(newtlink);
4316                         goto wait_for_construction;
4317                 }
4318                 tlink = newtlink;
4319                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4320                 spin_unlock(&cifs_sb->tlink_tree_lock);
4321         } else {
4322 wait_for_construction:
4323                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4324                                   TASK_INTERRUPTIBLE);
4325                 if (ret) {
4326                         cifs_put_tlink(tlink);
4327                         return ERR_PTR(-ERESTARTSYS);
4328                 }
4329
4330                 /* if it's good, return it */
4331                 if (!IS_ERR(tlink->tl_tcon))
4332                         return tlink;
4333
4334                 /* return error if we tried this already recently */
4335                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4336                         cifs_put_tlink(tlink);
4337                         return ERR_PTR(-EACCES);
4338                 }
4339
4340                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4341                         goto wait_for_construction;
4342         }
4343
4344         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4345         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4346         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4347
4348         if (IS_ERR(tlink->tl_tcon)) {
4349                 cifs_put_tlink(tlink);
4350                 return ERR_PTR(-EACCES);
4351         }
4352
4353         return tlink;
4354 }
4355
4356 /*
4357  * periodic workqueue job that scans tcon_tree for a superblock and closes
4358  * out tcons.
4359  */
4360 static void
4361 cifs_prune_tlinks(struct work_struct *work)
4362 {
4363         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4364                                                     prune_tlinks.work);
4365         struct rb_root *root = &cifs_sb->tlink_tree;
4366         struct rb_node *node = rb_first(root);
4367         struct rb_node *tmp;
4368         struct tcon_link *tlink;
4369
4370         /*
4371          * Because we drop the spinlock in the loop in order to put the tlink
4372          * it's not guarded against removal of links from the tree. The only
4373          * places that remove entries from the tree are this function and
4374          * umounts. Because this function is non-reentrant and is canceled
4375          * before umount can proceed, this is safe.
4376          */
4377         spin_lock(&cifs_sb->tlink_tree_lock);
4378         node = rb_first(root);
4379         while (node != NULL) {
4380                 tmp = node;
4381                 node = rb_next(tmp);
4382                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4383
4384                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4385                     atomic_read(&tlink->tl_count) != 0 ||
4386                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4387                         continue;
4388
4389                 cifs_get_tlink(tlink);
4390                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4391                 rb_erase(tmp, root);
4392
4393                 spin_unlock(&cifs_sb->tlink_tree_lock);
4394                 cifs_put_tlink(tlink);
4395                 spin_lock(&cifs_sb->tlink_tree_lock);
4396         }
4397         spin_unlock(&cifs_sb->tlink_tree_lock);
4398
4399         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4400                                 TLINK_IDLE_EXPIRE);
4401 }