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