fs/cifs/connect.c

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