fs/cifs/connect.c

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