fs/cifs/connect.c

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