fs/cifs/connect.c

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