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