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