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 = server->pdu_size;
 776
 777         /* make sure this will fit in a large buffer */
 778         if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) -
 779                 server->vals->header_preamble_size) {
 780                 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length);
 781                 cifs_reconnect(server);
 782                 wake_up(&server->response_q);
 783                 return -ECONNABORTED;
 784         }
 785
 786         /* switch to large buffer if too big for a small one */
 787         if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 788                 server->large_buf = true;
 789                 memcpy(server->bigbuf, buf, server->total_read);
 790                 buf = server->bigbuf;
 791         }
 792
 793         /* now read the rest */
 794         length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
 795                                        pdu_length - HEADER_SIZE(server) + 1
 796                                        + server->vals->header_preamble_size);
 797
 798         if (length < 0)
 799                 return length;
 800         server->total_read += length;
 801
 802         dump_smb(buf, server->total_read);
 803
 804         return cifs_handle_standard(server, mid);
 805 }
 806
 807 int
 808 cifs_handle_standard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
 809 {
 810         char *buf = server->large_buf ? server->bigbuf : server->smallbuf;
 811         int length;
 812
 813         /*
 814          * We know that we received enough to get to the MID as we
 815          * checked the pdu_length earlier. Now check to see
 816          * if the rest of the header is OK. We borrow the length
 817          * var for the rest of the loop to avoid a new stack var.
 818          *
 819          * 48 bytes is enough to display the header and a little bit
 820          * into the payload for debugging purposes.
 821          */
 822         length = server->ops->check_message(buf, server->total_read, server);
 823         if (length != 0)
 824                 cifs_dump_mem("Bad SMB: ", buf,
 825                         min_t(unsigned int, server->total_read, 48));
 826
 827         if (server->ops->is_session_expired &&
 828             server->ops->is_session_expired(buf)) {
 829                 cifs_reconnect(server);
 830                 wake_up(&server->response_q);
 831                 return -1;
 832         }
 833
 834         if (server->ops->is_status_pending &&
 835             server->ops->is_status_pending(buf, server, length))
 836                 return -1;
 837
 838         if (!mid)
 839                 return length;
 840
 841         handle_mid(mid, server, buf, length);
 842         return 0;
 843 }
 844
 845 static int
 846 cifs_demultiplex_thread(void *p)
 847 {
 848         int length;
 849         struct TCP_Server_Info *server = p;
 850         unsigned int pdu_length;
 851         char *buf = NULL;
 852         struct task_struct *task_to_wake = NULL;
 853         struct mid_q_entry *mid_entry;
 854
 855         current->flags |= PF_MEMALLOC;
 856         cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current));
 857
 858         length = atomic_inc_return(&tcpSesAllocCount);
 859         if (length > 1)
 860                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv);
 861
 862         set_freezable();
 863         while (server->tcpStatus != CifsExiting) {
 864                 if (try_to_freeze())
 865                         continue;
 866
 867                 if (!allocate_buffers(server))
 868                         continue;
 869
 870                 server->large_buf = false;
 871                 buf = server->smallbuf;
 872                 pdu_length = 4; /* enough to get RFC1001 header */
 873
 874                 length = cifs_read_from_socket(server, buf, pdu_length);
 875                 if (length < 0)
 876                         continue;
 877                 server->total_read = length;
 878
 879                 /*
 880                  * The right amount was read from socket - 4 bytes,
 881                  * so we can now interpret the length field.
 882                  */
 883                 pdu_length = get_rfc1002_length(buf);
 884                 server->pdu_size = pdu_length;
 885
 886                 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length);
 887                 if (!is_smb_response(server, buf[0]))
 888                         continue;
 889
 890                 /* make sure we have enough to get to the MID */
 891                 if (pdu_length < HEADER_SIZE(server) - 1 -
 892                     server->vals->header_preamble_size) {
 893                         cifs_dbg(VFS, "SMB response too short (%u bytes)\n",
 894                                  pdu_length);
 895                         cifs_reconnect(server);
 896                         wake_up(&server->response_q);
 897                         continue;
 898                 }
 899
 900                 /* read down to the MID */
 901                 length = cifs_read_from_socket(server,
 902                              buf + server->vals->header_preamble_size,
 903                              HEADER_SIZE(server) - 1
 904                              - server->vals->header_preamble_size);
 905                 if (length < 0)
 906                         continue;
 907                 server->total_read += length;
 908
 909                 if (server->ops->is_transform_hdr &&
 910                     server->ops->receive_transform &&
 911                     server->ops->is_transform_hdr(buf)) {
 912                         length = server->ops->receive_transform(server,
 913                                                                 &mid_entry);
 914                 } else {
 915                         mid_entry = server->ops->find_mid(server, buf);
 916
 917                         if (!mid_entry || !mid_entry->receive)
 918                                 length = standard_receive3(server, mid_entry);
 919                         else
 920                                 length = mid_entry->receive(server, mid_entry);
 921                 }
 922
 923                 if (length < 0)
 924                         continue;
 925
 926                 if (server->large_buf)
 927                         buf = server->bigbuf;
 928
 929                 server->lstrp = jiffies;
 930                 if (mid_entry != NULL) {
 931                         mid_entry->resp_buf_size = server->pdu_size;
 932                         if ((mid_entry->mid_flags & MID_WAIT_CANCELLED) &&
 933                              mid_entry->mid_state == MID_RESPONSE_RECEIVED &&
 934                                         server->ops->handle_cancelled_mid)
 935                                 server->ops->handle_cancelled_mid(
 936                                                         mid_entry->resp_buf,
 937                                                         server);
 938
 939                         if (!mid_entry->multiRsp || mid_entry->multiEnd)
 940                                 mid_entry->callback(mid_entry);
 941                 } else if (server->ops->is_oplock_break &&
 942                            server->ops->is_oplock_break(buf, server)) {
 943                         cifs_dbg(FYI, "Received oplock break\n");
 944                 } else {
 945                         cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n",
 946                                  atomic_read(&midCount));
 947                         cifs_dump_mem("Received Data is: ", buf,
 948                                       HEADER_SIZE(server));
 949 #ifdef CONFIG_CIFS_DEBUG2
 950                         if (server->ops->dump_detail)
 951                                 server->ops->dump_detail(buf);
 952                         cifs_dump_mids(server);
 953 #endif /* CIFS_DEBUG2 */
 954
 955                 }
 956         } /* end while !EXITING */
 957
 958         /* buffer usually freed in free_mid - need to free it here on exit */
 959         cifs_buf_release(server->bigbuf);
 960         if (server->smallbuf) /* no sense logging a debug message if NULL */
 961                 cifs_small_buf_release(server->smallbuf);
 962
 963         task_to_wake = xchg(&server->tsk, NULL);
 964         clean_demultiplex_info(server);
 965
 966         /* if server->tsk was NULL then wait for a signal before exiting */
 967         if (!task_to_wake) {
 968                 set_current_state(TASK_INTERRUPTIBLE);
 969                 while (!signal_pending(current)) {
 970                         schedule();
 971                         set_current_state(TASK_INTERRUPTIBLE);
 972                 }
 973                 set_current_state(TASK_RUNNING);
 974         }
 975
 976         module_put_and_exit(0);
 977 }
 978
 979 /* extract the host portion of the UNC string */
 980 static char *
 981 extract_hostname(const char *unc)
 982 {
 983         const char *src;
 984         char *dst, *delim;
 985         unsigned int len;
 986
 987         /* skip double chars at beginning of string */
 988         /* BB: check validity of these bytes? */
 989         src = unc + 2;
 990
 991         /* delimiter between hostname and sharename is always '\\' now */
 992         delim = strchr(src, '\\');
 993         if (!delim)
 994                 return ERR_PTR(-EINVAL);
 995
 996         len = delim - src;
 997         dst = kmalloc((len + 1), GFP_KERNEL);
 998         if (dst == NULL)
 999                 return ERR_PTR(-ENOMEM);
1000
1001         memcpy(dst, src, len);
1002         dst[len] = '\0';
1003
1004         return dst;
1005 }
1006
1007 static int get_option_ul(substring_t args[], unsigned long *option)
1008 {
1009         int rc;
1010         char *string;
1011
1012         string = match_strdup(args);
1013         if (string == NULL)
1014                 return -ENOMEM;
1015         rc = kstrtoul(string, 0, option);
1016         kfree(string);
1017
1018         return rc;
1019 }
1020
1021 static int get_option_uid(substring_t args[], kuid_t *result)
1022 {
1023         unsigned long value;
1024         kuid_t uid;
1025         int rc;
1026
1027         rc = get_option_ul(args, &value);
1028         if (rc)
1029                 return rc;
1030
1031         uid = make_kuid(current_user_ns(), value);
1032         if (!uid_valid(uid))
1033                 return -EINVAL;
1034
1035         *result = uid;
1036         return 0;
1037 }
1038
1039 static int get_option_gid(substring_t args[], kgid_t *result)
1040 {
1041         unsigned long value;
1042         kgid_t gid;
1043         int rc;
1044
1045         rc = get_option_ul(args, &value);
1046         if (rc)
1047                 return rc;
1048
1049         gid = make_kgid(current_user_ns(), value);
1050         if (!gid_valid(gid))
1051                 return -EINVAL;
1052
1053         *result = gid;
1054         return 0;
1055 }
1056
1057 static int cifs_parse_security_flavors(char *value,
1058                                        struct smb_vol *vol)
1059 {
1060
1061         substring_t args[MAX_OPT_ARGS];
1062
1063         /*
1064          * With mount options, the last one should win. Reset any existing
1065          * settings back to default.
1066          */
1067         vol->sectype = Unspecified;
1068         vol->sign = false;
1069
1070         switch (match_token(value, cifs_secflavor_tokens, args)) {
1071         case Opt_sec_krb5p:
1072                 cifs_dbg(VFS, "sec=krb5p is not supported!\n");
1073                 return 1;
1074         case Opt_sec_krb5i:
1075                 vol->sign = true;
1076                 /* Fallthrough */
1077         case Opt_sec_krb5:
1078                 vol->sectype = Kerberos;
1079                 break;
1080         case Opt_sec_ntlmsspi:
1081                 vol->sign = true;
1082                 /* Fallthrough */
1083         case Opt_sec_ntlmssp:
1084                 vol->sectype = RawNTLMSSP;
1085                 break;
1086         case Opt_sec_ntlmi:
1087                 vol->sign = true;
1088                 /* Fallthrough */
1089         case Opt_ntlm:
1090                 vol->sectype = NTLM;
1091                 break;
1092         case Opt_sec_ntlmv2i:
1093                 vol->sign = true;
1094                 /* Fallthrough */
1095         case Opt_sec_ntlmv2:
1096                 vol->sectype = NTLMv2;
1097                 break;
1098 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1099         case Opt_sec_lanman:
1100                 vol->sectype = LANMAN;
1101                 break;
1102 #endif
1103         case Opt_sec_none:
1104                 vol->nullauth = 1;
1105                 break;
1106         default:
1107                 cifs_dbg(VFS, "bad security option: %s\n", value);
1108                 return 1;
1109         }
1110
1111         return 0;
1112 }
1113
1114 static int
1115 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1116 {
1117         substring_t args[MAX_OPT_ARGS];
1118
1119         switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1120         case Opt_cache_loose:
1121                 vol->direct_io = false;
1122                 vol->strict_io = false;
1123                 break;
1124         case Opt_cache_strict:
1125                 vol->direct_io = false;
1126                 vol->strict_io = true;
1127                 break;
1128         case Opt_cache_none:
1129                 vol->direct_io = true;
1130                 vol->strict_io = false;
1131                 break;
1132         default:
1133                 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1134                 return 1;
1135         }
1136         return 0;
1137 }
1138
1139 static int
1140 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1141 {
1142         substring_t args[MAX_OPT_ARGS];
1143
1144         switch (match_token(value, cifs_smb_version_tokens, args)) {
1145         case Smb_1:
1146                 vol->ops = &smb1_operations;
1147                 vol->vals = &smb1_values;
1148                 break;
1149         case Smb_20:
1150                 vol->ops = &smb20_operations;
1151                 vol->vals = &smb20_values;
1152                 break;
1153         case Smb_21:
1154                 vol->ops = &smb21_operations;
1155                 vol->vals = &smb21_values;
1156                 break;
1157         case Smb_30:
1158                 vol->ops = &smb30_operations;
1159                 vol->vals = &smb30_values;
1160                 break;
1161         case Smb_302:
1162                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1163                 vol->vals = &smb302_values;
1164                 break;
1165 #ifdef CONFIG_CIFS_SMB311
1166         case Smb_311:
1167                 vol->ops = &smb311_operations;
1168                 vol->vals = &smb311_values;
1169                 break;
1170 #endif /* SMB311 */
1171         case Smb_3any:
1172                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1173                 vol->vals = &smb3any_values;
1174                 break;
1175         case Smb_default:
1176                 vol->ops = &smb30_operations; /* currently identical with 3.0 */
1177                 vol->vals = &smbdefault_values;
1178                 break;
1179         default:
1180                 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1181                 return 1;
1182         }
1183         return 0;
1184 }
1185
1186 /*
1187  * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1188  * fields with the result. Returns 0 on success and an error otherwise.
1189  */
1190 static int
1191 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1192 {
1193         char *pos;
1194         const char *delims = "/\\";
1195         size_t len;
1196
1197         /* make sure we have a valid UNC double delimiter prefix */
1198         len = strspn(devname, delims);
1199         if (len != 2)
1200                 return -EINVAL;
1201
1202         /* find delimiter between host and sharename */
1203         pos = strpbrk(devname + 2, delims);
1204         if (!pos)
1205                 return -EINVAL;
1206
1207         /* skip past delimiter */
1208         ++pos;
1209
1210         /* now go until next delimiter or end of string */
1211         len = strcspn(pos, delims);
1212
1213         /* move "pos" up to delimiter or NULL */
1214         pos += len;
1215         vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1216         if (!vol->UNC)
1217                 return -ENOMEM;
1218
1219         convert_delimiter(vol->UNC, '\\');
1220
1221         /* skip any delimiter */
1222         if (*pos == '/' || *pos == '\\')
1223                 pos++;
1224
1225         /* If pos is NULL then no prepath */
1226         if (!*pos)
1227                 return 0;
1228
1229         vol->prepath = kstrdup(pos, GFP_KERNEL);
1230         if (!vol->prepath)
1231                 return -ENOMEM;
1232
1233         return 0;
1234 }
1235
1236 static int
1237 cifs_parse_mount_options(const char *mountdata, const char *devname,
1238                          struct smb_vol *vol)
1239 {
1240         char *data, *end;
1241         char *mountdata_copy = NULL, *options;
1242         unsigned int  temp_len, i, j;
1243         char separator[2];
1244         short int override_uid = -1;
1245         short int override_gid = -1;
1246         bool uid_specified = false;
1247         bool gid_specified = false;
1248         bool sloppy = false;
1249         char *invalid = NULL;
1250         char *nodename = utsname()->nodename;
1251         char *string = NULL;
1252         char *tmp_end, *value;
1253         char delim;
1254         bool got_ip = false;
1255         bool got_version = false;
1256         unsigned short port = 0;
1257         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1258
1259         separator[0] = ',';
1260         separator[1] = 0;
1261         delim = separator[0];
1262
1263         /* ensure we always start with zeroed-out smb_vol */
1264         memset(vol, 0, sizeof(*vol));
1265
1266         /*
1267          * does not have to be perfect mapping since field is
1268          * informational, only used for servers that do not support
1269          * port 445 and it can be overridden at mount time
1270          */
1271         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1272         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1273                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1274
1275         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1276         /* null target name indicates to use *SMBSERVR default called name
1277            if we end up sending RFC1001 session initialize */
1278         vol->target_rfc1001_name[0] = 0;
1279         vol->cred_uid = current_uid();
1280         vol->linux_uid = current_uid();
1281         vol->linux_gid = current_gid();
1282
1283         /*
1284          * default to SFM style remapping of seven reserved characters
1285          * unless user overrides it or we negotiate CIFS POSIX where
1286          * it is unnecessary.  Can not simultaneously use more than one mapping
1287          * since then readdir could list files that open could not open
1288          */
1289         vol->remap = true;
1290
1291         /* default to only allowing write access to owner of the mount */
1292         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1293
1294         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1295         /* default is always to request posix paths. */
1296         vol->posix_paths = 1;
1297         /* default to using server inode numbers where available */
1298         vol->server_ino = 1;
1299
1300         /* default is to use strict cifs caching semantics */
1301         vol->strict_io = true;
1302
1303         vol->actimeo = CIFS_DEF_ACTIMEO;
1304
1305         /* offer SMB2.1 and later (SMB3 etc). Secure and widely accepted */
1306         vol->ops = &smb30_operations;
1307         vol->vals = &smbdefault_values;
1308
1309         vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1310
1311         if (!mountdata)
1312                 goto cifs_parse_mount_err;
1313
1314         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1315         if (!mountdata_copy)
1316                 goto cifs_parse_mount_err;
1317
1318         options = mountdata_copy;
1319         end = options + strlen(options);
1320
1321         if (strncmp(options, "sep=", 4) == 0) {
1322                 if (options[4] != 0) {
1323                         separator[0] = options[4];
1324                         options += 5;
1325                 } else {
1326                         cifs_dbg(FYI, "Null separator not allowed\n");
1327                 }
1328         }
1329         vol->backupuid_specified = false; /* no backup intent for a user */
1330         vol->backupgid_specified = false; /* no backup intent for a group */
1331
1332         switch (cifs_parse_devname(devname, vol)) {
1333         case 0:
1334                 break;
1335         case -ENOMEM:
1336                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1337                 goto cifs_parse_mount_err;
1338         case -EINVAL:
1339                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1340                 goto cifs_parse_mount_err;
1341         default:
1342                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1343                 goto cifs_parse_mount_err;
1344         }
1345
1346         while ((data = strsep(&options, separator)) != NULL) {
1347                 substring_t args[MAX_OPT_ARGS];
1348                 unsigned long option;
1349                 int token;
1350
1351                 if (!*data)
1352                         continue;
1353
1354                 token = match_token(data, cifs_mount_option_tokens, args);
1355
1356                 switch (token) {
1357
1358                 /* Ingnore the following */
1359                 case Opt_ignore:
1360                         break;
1361
1362                 /* Boolean values */
1363                 case Opt_user_xattr:
1364                         vol->no_xattr = 0;
1365                         break;
1366                 case Opt_nouser_xattr:
1367                         vol->no_xattr = 1;
1368                         break;
1369                 case Opt_forceuid:
1370                         override_uid = 1;
1371                         break;
1372                 case Opt_noforceuid:
1373                         override_uid = 0;
1374                         break;
1375                 case Opt_forcegid:
1376                         override_gid = 1;
1377                         break;
1378                 case Opt_noforcegid:
1379                         override_gid = 0;
1380                         break;
1381                 case Opt_noblocksend:
1382                         vol->noblocksnd = 1;
1383                         break;
1384                 case Opt_noautotune:
1385                         vol->noautotune = 1;
1386                         break;
1387                 case Opt_hard:
1388                         vol->retry = 1;
1389                         break;
1390                 case Opt_soft:
1391                         vol->retry = 0;
1392                         break;
1393                 case Opt_perm:
1394                         vol->noperm = 0;
1395                         break;
1396                 case Opt_noperm:
1397                         vol->noperm = 1;
1398                         break;
1399                 case Opt_mapchars:
1400                         vol->sfu_remap = true;
1401                         vol->remap = false; /* disable SFM mapping */
1402                         break;
1403                 case Opt_nomapchars:
1404                         vol->sfu_remap = false;
1405                         break;
1406                 case Opt_mapposix:
1407                         vol->remap = true;
1408                         vol->sfu_remap = false; /* disable SFU mapping */
1409                         break;
1410                 case Opt_nomapposix:
1411                         vol->remap = false;
1412                         break;
1413                 case Opt_sfu:
1414                         vol->sfu_emul = 1;
1415                         break;
1416                 case Opt_nosfu:
1417                         vol->sfu_emul = 0;
1418                         break;
1419                 case Opt_nodfs:
1420                         vol->nodfs = 1;
1421                         break;
1422                 case Opt_posixpaths:
1423                         vol->posix_paths = 1;
1424                         break;
1425                 case Opt_noposixpaths:
1426                         vol->posix_paths = 0;
1427                         break;
1428                 case Opt_nounix:
1429                         vol->no_linux_ext = 1;
1430                         break;
1431                 case Opt_nocase:
1432                         vol->nocase = 1;
1433                         break;
1434                 case Opt_brl:
1435                         vol->nobrl =  0;
1436                         break;
1437                 case Opt_nobrl:
1438                         vol->nobrl =  1;
1439                         /*
1440                          * turn off mandatory locking in mode
1441                          * if remote locking is turned off since the
1442                          * local vfs will do advisory
1443                          */
1444                         if (vol->file_mode ==
1445                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1446                                 vol->file_mode = S_IALLUGO;
1447                         break;
1448                 case Opt_forcemandatorylock:
1449                         vol->mand_lock = 1;
1450                         break;
1451                 case Opt_setuids:
1452                         vol->setuids = 1;
1453                         break;
1454                 case Opt_nosetuids:
1455                         vol->setuids = 0;
1456                         break;
1457                 case Opt_setuidfromacl:
1458                         vol->setuidfromacl = 1;
1459                         break;
1460                 case Opt_dynperm:
1461                         vol->dynperm = true;
1462                         break;
1463                 case Opt_nodynperm:
1464                         vol->dynperm = false;
1465                         break;
1466                 case Opt_nohard:
1467                         vol->retry = 0;
1468                         break;
1469                 case Opt_nosoft:
1470                         vol->retry = 1;
1471                         break;
1472                 case Opt_nointr:
1473                         vol->intr = 0;
1474                         break;
1475                 case Opt_intr:
1476                         vol->intr = 1;
1477                         break;
1478                 case Opt_nostrictsync:
1479                         vol->nostrictsync = 1;
1480                         break;
1481                 case Opt_strictsync:
1482                         vol->nostrictsync = 0;
1483                         break;
1484                 case Opt_serverino:
1485                         vol->server_ino = 1;
1486                         break;
1487                 case Opt_noserverino:
1488                         vol->server_ino = 0;
1489                         break;
1490                 case Opt_rwpidforward:
1491                         vol->rwpidforward = 1;
1492                         break;
1493                 case Opt_cifsacl:
1494                         vol->cifs_acl = 1;
1495                         break;
1496                 case Opt_nocifsacl:
1497                         vol->cifs_acl = 0;
1498                         break;
1499                 case Opt_acl:
1500                         vol->no_psx_acl = 0;
1501                         break;
1502                 case Opt_noacl:
1503                         vol->no_psx_acl = 1;
1504                         break;
1505                 case Opt_locallease:
1506                         vol->local_lease = 1;
1507                         break;
1508                 case Opt_sign:
1509                         vol->sign = true;
1510                         break;
1511                 case Opt_seal:
1512                         /* we do not do the following in secFlags because seal
1513                          * is a per tree connection (mount) not a per socket
1514                          * or per-smb connection option in the protocol
1515                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1516                          */
1517                         vol->seal = 1;
1518                         break;
1519                 case Opt_noac:
1520                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1521                         break;
1522                 case Opt_fsc:
1523 #ifndef CONFIG_CIFS_FSCACHE
1524                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1525                         goto cifs_parse_mount_err;
1526 #endif
1527                         vol->fsc = true;
1528                         break;
1529                 case Opt_mfsymlinks:
1530                         vol->mfsymlinks = true;
1531                         break;
1532                 case Opt_multiuser:
1533                         vol->multiuser = true;
1534                         break;
1535                 case Opt_sloppy:
1536                         sloppy = true;
1537                         break;
1538                 case Opt_nosharesock:
1539                         vol->nosharesock = true;
1540                         break;
1541                 case Opt_nopersistent:
1542                         vol->nopersistent = true;
1543                         if (vol->persistent) {
1544                                 cifs_dbg(VFS,
1545                                   "persistenthandles mount options conflict\n");
1546                                 goto cifs_parse_mount_err;
1547                         }
1548                         break;
1549                 case Opt_persistent:
1550                         vol->persistent = true;
1551                         if ((vol->nopersistent) || (vol->resilient)) {
1552                                 cifs_dbg(VFS,
1553                                   "persistenthandles mount options conflict\n");
1554                                 goto cifs_parse_mount_err;
1555                         }
1556                         break;
1557                 case Opt_resilient:
1558                         vol->resilient = true;
1559                         if (vol->persistent) {
1560                                 cifs_dbg(VFS,
1561                                   "persistenthandles mount options conflict\n");
1562                                 goto cifs_parse_mount_err;
1563                         }
1564                         break;
1565                 case Opt_noresilient:
1566                         vol->resilient = false; /* already the default */
1567                         break;
1568                 case Opt_domainauto:
1569                         vol->domainauto = true;
1570                         break;
1571                 case Opt_rdma:
1572                         vol->rdma = true;
1573                         break;
1574
1575                 /* Numeric Values */
1576                 case Opt_backupuid:
1577                         if (get_option_uid(args, &vol->backupuid)) {
1578                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1579                                          __func__);
1580                                 goto cifs_parse_mount_err;
1581                         }
1582                         vol->backupuid_specified = true;
1583                         break;
1584                 case Opt_backupgid:
1585                         if (get_option_gid(args, &vol->backupgid)) {
1586                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1587                                          __func__);
1588                                 goto cifs_parse_mount_err;
1589                         }
1590                         vol->backupgid_specified = true;
1591                         break;
1592                 case Opt_uid:
1593                         if (get_option_uid(args, &vol->linux_uid)) {
1594                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1595                                          __func__);
1596                                 goto cifs_parse_mount_err;
1597                         }
1598                         uid_specified = true;
1599                         break;
1600                 case Opt_cruid:
1601                         if (get_option_uid(args, &vol->cred_uid)) {
1602                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1603                                          __func__);
1604                                 goto cifs_parse_mount_err;
1605                         }
1606                         break;
1607                 case Opt_gid:
1608                         if (get_option_gid(args, &vol->linux_gid)) {
1609                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
1610                                          __func__);
1611                                 goto cifs_parse_mount_err;
1612                         }
1613                         gid_specified = true;
1614                         break;
1615                 case Opt_file_mode:
1616                         if (get_option_ul(args, &option)) {
1617                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1618                                          __func__);
1619                                 goto cifs_parse_mount_err;
1620                         }
1621                         vol->file_mode = option;
1622                         break;
1623                 case Opt_dirmode:
1624                         if (get_option_ul(args, &option)) {
1625                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1626                                          __func__);
1627                                 goto cifs_parse_mount_err;
1628                         }
1629                         vol->dir_mode = option;
1630                         break;
1631                 case Opt_port:
1632                         if (get_option_ul(args, &option) ||
1633                             option > USHRT_MAX) {
1634                                 cifs_dbg(VFS, "%s: Invalid port value\n",
1635                                          __func__);
1636                                 goto cifs_parse_mount_err;
1637                         }
1638                         port = (unsigned short)option;
1639                         break;
1640                 case Opt_rsize:
1641                         if (get_option_ul(args, &option)) {
1642                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1643                                          __func__);
1644                                 goto cifs_parse_mount_err;
1645                         }
1646                         vol->rsize = option;
1647                         break;
1648                 case Opt_wsize:
1649                         if (get_option_ul(args, &option)) {
1650                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1651                                          __func__);
1652                                 goto cifs_parse_mount_err;
1653                         }
1654                         vol->wsize = option;
1655                         break;
1656                 case Opt_actimeo:
1657                         if (get_option_ul(args, &option)) {
1658                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1659                                          __func__);
1660                                 goto cifs_parse_mount_err;
1661                         }
1662                         vol->actimeo = HZ * option;
1663                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1664                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
1665                                 goto cifs_parse_mount_err;
1666                         }
1667                         break;
1668                 case Opt_echo_interval:
1669                         if (get_option_ul(args, &option)) {
1670                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1671                                          __func__);
1672                                 goto cifs_parse_mount_err;
1673                         }
1674                         vol->echo_interval = option;
1675                         break;
1676                 case Opt_snapshot:
1677                         if (get_option_ul(args, &option)) {
1678                                 cifs_dbg(VFS, "%s: Invalid snapshot time\n",
1679                                          __func__);
1680                                 goto cifs_parse_mount_err;
1681                         }
1682                         vol->snapshot_time = option;
1683                         break;
1684                 case Opt_max_credits:
1685                         if (get_option_ul(args, &option) || (option < 20) ||
1686                             (option > 60000)) {
1687                                 cifs_dbg(VFS, "%s: Invalid max_credits value\n",
1688                                          __func__);
1689                                 goto cifs_parse_mount_err;
1690                         }
1691                         vol->max_credits = option;
1692                         break;
1693
1694                 /* String Arguments */
1695
1696                 case Opt_blank_user:
1697                         /* null user, ie. anonymous authentication */
1698                         vol->nullauth = 1;
1699                         vol->username = NULL;
1700                         break;
1701                 case Opt_user:
1702                         string = match_strdup(args);
1703                         if (string == NULL)
1704                                 goto out_nomem;
1705
1706                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1707                                                         CIFS_MAX_USERNAME_LEN) {
1708                                 pr_warn("CIFS: username too long\n");
1709                                 goto cifs_parse_mount_err;
1710                         }
1711
1712                         kfree(vol->username);
1713                         vol->username = kstrdup(string, GFP_KERNEL);
1714                         if (!vol->username)
1715                                 goto cifs_parse_mount_err;
1716                         break;
1717                 case Opt_blank_pass:
1718                         /* passwords have to be handled differently
1719                          * to allow the character used for deliminator
1720                          * to be passed within them
1721                          */
1722
1723                         /*
1724                          * Check if this is a case where the  password
1725                          * starts with a delimiter
1726                          */
1727                         tmp_end = strchr(data, '=');
1728                         tmp_end++;
1729                         if (!(tmp_end < end && tmp_end[1] == delim)) {
1730                                 /* No it is not. Set the password to NULL */
1731                                 kzfree(vol->password);
1732                                 vol->password = NULL;
1733                                 break;
1734                         }
1735                         /* Yes it is. Drop down to Opt_pass below.*/
1736                 case Opt_pass:
1737                         /* Obtain the value string */
1738                         value = strchr(data, '=');
1739                         value++;
1740
1741                         /* Set tmp_end to end of the string */
1742                         tmp_end = (char *) value + strlen(value);
1743
1744                         /* Check if following character is the deliminator
1745                          * If yes, we have encountered a double deliminator
1746                          * reset the NULL character to the deliminator
1747                          */
1748                         if (tmp_end < end && tmp_end[1] == delim) {
1749                                 tmp_end[0] = delim;
1750
1751                                 /* Keep iterating until we get to a single
1752                                  * deliminator OR the end
1753                                  */
1754                                 while ((tmp_end = strchr(tmp_end, delim))
1755                                         != NULL && (tmp_end[1] == delim)) {
1756                                                 tmp_end = (char *) &tmp_end[2];
1757                                 }
1758
1759                                 /* Reset var options to point to next element */
1760                                 if (tmp_end) {
1761                                         tmp_end[0] = '\0';
1762                                         options = (char *) &tmp_end[1];
1763                                 } else
1764                                         /* Reached the end of the mount option
1765                                          * string */
1766                                         options = end;
1767                         }
1768
1769                         kzfree(vol->password);
1770                         /* Now build new password string */
1771                         temp_len = strlen(value);
1772                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1773                         if (vol->password == NULL) {
1774                                 pr_warn("CIFS: no memory for password\n");
1775                                 goto cifs_parse_mount_err;
1776                         }
1777
1778                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1779                                 vol->password[j] = value[i];
1780                                 if ((value[i] == delim) &&
1781                                      value[i+1] == delim)
1782                                         /* skip the second deliminator */
1783                                         i++;
1784                         }
1785                         vol->password[j] = '\0';
1786                         break;
1787                 case Opt_blank_ip:
1788                         /* FIXME: should this be an error instead? */
1789                         got_ip = false;
1790                         break;
1791                 case Opt_ip:
1792                         string = match_strdup(args);
1793                         if (string == NULL)
1794                                 goto out_nomem;
1795
1796                         if (!cifs_convert_address(dstaddr, string,
1797                                         strlen(string))) {
1798                                 pr_err("CIFS: bad ip= option (%s).\n", string);
1799                                 goto cifs_parse_mount_err;
1800                         }
1801                         got_ip = true;
1802                         break;
1803                 case Opt_domain:
1804                         string = match_strdup(args);
1805                         if (string == NULL)
1806                                 goto out_nomem;
1807
1808                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1809                                         == CIFS_MAX_DOMAINNAME_LEN) {
1810                                 pr_warn("CIFS: domain name too long\n");
1811                                 goto cifs_parse_mount_err;
1812                         }
1813
1814                         kfree(vol->domainname);
1815                         vol->domainname = kstrdup(string, GFP_KERNEL);
1816                         if (!vol->domainname) {
1817                                 pr_warn("CIFS: no memory for domainname\n");
1818                                 goto cifs_parse_mount_err;
1819                         }
1820                         cifs_dbg(FYI, "Domain name set\n");
1821                         break;
1822                 case Opt_srcaddr:
1823                         string = match_strdup(args);
1824                         if (string == NULL)
1825                                 goto out_nomem;
1826
1827                         if (!cifs_convert_address(
1828                                         (struct sockaddr *)&vol->srcaddr,
1829                                         string, strlen(string))) {
1830                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1831                                         string);
1832                                 goto cifs_parse_mount_err;
1833                         }
1834                         break;
1835                 case Opt_iocharset:
1836                         string = match_strdup(args);
1837                         if (string == NULL)
1838                                 goto out_nomem;
1839
1840                         if (strnlen(string, 1024) >= 65) {
1841                                 pr_warn("CIFS: iocharset name too long.\n");
1842                                 goto cifs_parse_mount_err;
1843                         }
1844
1845                          if (strncasecmp(string, "default", 7) != 0) {
1846                                 kfree(vol->iocharset);
1847                                 vol->iocharset = kstrdup(string,
1848                                                          GFP_KERNEL);
1849                                 if (!vol->iocharset) {
1850                                         pr_warn("CIFS: no memory for charset\n");
1851                                         goto cifs_parse_mount_err;
1852                                 }
1853                         }
1854                         /* if iocharset not set then load_nls_default
1855                          * is used by caller
1856                          */
1857                          cifs_dbg(FYI, "iocharset set to %s\n", string);
1858                         break;
1859                 case Opt_netbiosname:
1860                         string = match_strdup(args);
1861                         if (string == NULL)
1862                                 goto out_nomem;
1863
1864                         memset(vol->source_rfc1001_name, 0x20,
1865                                 RFC1001_NAME_LEN);
1866                         /*
1867                          * FIXME: are there cases in which a comma can
1868                          * be valid in workstation netbios name (and
1869                          * need special handling)?
1870                          */
1871                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1872                                 /* don't ucase netbiosname for user */
1873                                 if (string[i] == 0)
1874                                         break;
1875                                 vol->source_rfc1001_name[i] = string[i];
1876                         }
1877                         /* The string has 16th byte zero still from
1878                          * set at top of the function
1879                          */
1880                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1881                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1882                         break;
1883                 case Opt_servern:
1884                         /* servernetbiosname specified override *SMBSERVER */
1885                         string = match_strdup(args);
1886                         if (string == NULL)
1887                                 goto out_nomem;
1888
1889                         /* last byte, type, is 0x20 for servr type */
1890                         memset(vol->target_rfc1001_name, 0x20,
1891                                 RFC1001_NAME_LEN_WITH_NULL);
1892
1893                         /* BB are there cases in which a comma can be
1894                            valid in this workstation netbios name
1895                            (and need special handling)? */
1896
1897                         /* user or mount helper must uppercase the
1898                            netbios name */
1899                         for (i = 0; i < 15; i++) {
1900                                 if (string[i] == 0)
1901                                         break;
1902                                 vol->target_rfc1001_name[i] = string[i];
1903                         }
1904                         /* The string has 16th byte zero still from
1905                            set at top of the function  */
1906                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1907                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1908                         break;
1909                 case Opt_ver:
1910                         /* version of mount userspace tools, not dialect */
1911                         string = match_strdup(args);
1912                         if (string == NULL)
1913                                 goto out_nomem;
1914
1915                         /* If interface changes in mount.cifs bump to new ver */
1916                         if (strncasecmp(string, "1", 1) == 0) {
1917                                 if (strlen(string) > 1) {
1918                                         pr_warn("Bad mount helper ver=%s. Did "
1919                                                 "you want SMB1 (CIFS) dialect "
1920                                                 "and mean to type vers=1.0 "
1921                                                 "instead?\n", string);
1922                                         goto cifs_parse_mount_err;
1923                                 }
1924                                 /* This is the default */
1925                                 break;
1926                         }
1927                         /* For all other value, error */
1928                         pr_warn("CIFS: Invalid mount helper version specified\n");
1929                         goto cifs_parse_mount_err;
1930                 case Opt_vers:
1931                         /* protocol version (dialect) */
1932                         string = match_strdup(args);
1933                         if (string == NULL)
1934                                 goto out_nomem;
1935
1936                         if (cifs_parse_smb_version(string, vol) != 0)
1937                                 goto cifs_parse_mount_err;
1938                         got_version = true;
1939                         break;
1940                 case Opt_sec:
1941                         string = match_strdup(args);
1942                         if (string == NULL)
1943                                 goto out_nomem;
1944
1945                         if (cifs_parse_security_flavors(string, vol) != 0)
1946                                 goto cifs_parse_mount_err;
1947                         break;
1948                 case Opt_cache:
1949                         string = match_strdup(args);
1950                         if (string == NULL)
1951                                 goto out_nomem;
1952
1953                         if (cifs_parse_cache_flavor(string, vol) != 0)
1954                                 goto cifs_parse_mount_err;
1955                         break;
1956                 default:
1957                         /*
1958                          * An option we don't recognize. Save it off for later
1959                          * if we haven't already found one
1960                          */
1961                         if (!invalid)
1962                                 invalid = data;
1963                         break;
1964                 }
1965                 /* Free up any allocated string */
1966                 kfree(string);
1967                 string = NULL;
1968         }
1969
1970         if (!sloppy && invalid) {
1971                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1972                 goto cifs_parse_mount_err;
1973         }
1974
1975         if (vol->rdma && vol->vals->protocol_id < SMB30_PROT_ID) {
1976                 cifs_dbg(VFS, "SMB Direct requires Version >=3.0\n");
1977                 goto cifs_parse_mount_err;
1978         }
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         if (volume_info->seal) {
2955                 if (ses->server->vals->protocol_id == 0) {
2956                         cifs_dbg(VFS,
2957                                  "SMB3 or later required for encryption\n");
2958                         rc = -EOPNOTSUPP;
2959                         goto out_fail;
2960                 } else if (tcon->ses->server->capabilities &
2961                                         SMB2_GLOBAL_CAP_ENCRYPTION)
2962                         tcon->seal = true;
2963                 else {
2964                         cifs_dbg(VFS, "Encryption is not supported on share\n");
2965                         rc = -EOPNOTSUPP;
2966                         goto out_fail;
2967                 }
2968         }
2969
2970         /*
2971          * BB Do we need to wrap session_mutex around this TCon call and Unix
2972          * SetFS as we do on SessSetup and reconnect?
2973          */
2974         xid = get_xid();
2975         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2976                                             volume_info->local_nls);
2977         free_xid(xid);
2978         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2979         if (rc)
2980                 goto out_fail;
2981
2982         if (volume_info->nodfs) {
2983                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2984                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2985         }
2986         tcon->use_persistent = false;
2987         /* check if SMB2 or later, CIFS does not support persistent handles */
2988         if (volume_info->persistent) {
2989                 if (ses->server->vals->protocol_id == 0) {
2990                         cifs_dbg(VFS,
2991                              "SMB3 or later required for persistent handles\n");
2992                         rc = -EOPNOTSUPP;
2993                         goto out_fail;
2994                 } else if (ses->server->capabilities &
2995                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2996                         tcon->use_persistent = true;
2997                 else /* persistent handles requested but not supported */ {
2998                         cifs_dbg(VFS,
2999                                 "Persistent handles not supported on share\n");
3000                         rc = -EOPNOTSUPP;
3001                         goto out_fail;
3002                 }
3003         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
3004              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
3005              && (volume_info->nopersistent == false)) {
3006                 cifs_dbg(FYI, "enabling persistent handles\n");
3007                 tcon->use_persistent = true;
3008         } else if (volume_info->resilient) {
3009                 if (ses->server->vals->protocol_id == 0) {
3010                         cifs_dbg(VFS,
3011                              "SMB2.1 or later required for resilient handles\n");
3012                         rc = -EOPNOTSUPP;
3013                         goto out_fail;
3014                 }
3015                 tcon->use_resilient = true;
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(FYI, "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 }