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