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         mutex_unlock(&server->srv_mutex);
 374
 375         /* mark submitted MIDs for retry and issue callback */
 376         INIT_LIST_HEAD(&retry_list);
 377         cifs_dbg(FYI, "%s: moving mids to private list\n", __func__);
 378         spin_lock(&GlobalMid_Lock);
 379         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 380                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 381                 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
 382                         mid_entry->mid_state = MID_RETRY_NEEDED;
 383                 list_move(&mid_entry->qhead, &retry_list);
 384         }
 385         spin_unlock(&GlobalMid_Lock);
 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);
 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         /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1200         if (!*pos++ || !*pos)
1201                 return 0;
1202
1203         vol->prepath = kstrdup(pos, GFP_KERNEL);
1204         if (!vol->prepath)
1205                 return -ENOMEM;
1206
1207         return 0;
1208 }
1209
1210 static int
1211 cifs_parse_mount_options(const char *mountdata, const char *devname,
1212                          struct smb_vol *vol)
1213 {
1214         char *data, *end;
1215         char *mountdata_copy = NULL, *options;
1216         unsigned int  temp_len, i, j;
1217         char separator[2];
1218         short int override_uid = -1;
1219         short int override_gid = -1;
1220         bool uid_specified = false;
1221         bool gid_specified = false;
1222         bool sloppy = false;
1223         char *invalid = NULL;
1224         char *nodename = utsname()->nodename;
1225         char *string = NULL;
1226         char *tmp_end, *value;
1227         char delim;
1228         bool got_ip = false;
1229         unsigned short port = 0;
1230         struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1231
1232         separator[0] = ',';
1233         separator[1] = 0;
1234         delim = separator[0];
1235
1236         /* ensure we always start with zeroed-out smb_vol */
1237         memset(vol, 0, sizeof(*vol));
1238
1239         /*
1240          * does not have to be perfect mapping since field is
1241          * informational, only used for servers that do not support
1242          * port 445 and it can be overridden at mount time
1243          */
1244         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1245         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1246                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1247
1248         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1249         /* null target name indicates to use *SMBSERVR default called name
1250            if we end up sending RFC1001 session initialize */
1251         vol->target_rfc1001_name[0] = 0;
1252         vol->cred_uid = current_uid();
1253         vol->linux_uid = current_uid();
1254         vol->linux_gid = current_gid();
1255
1256         /*
1257          * default to SFM style remapping of seven reserved characters
1258          * unless user overrides it or we negotiate CIFS POSIX where
1259          * it is unnecessary.  Can not simultaneously use more than one mapping
1260          * since then readdir could list files that open could not open
1261          */
1262         vol->remap = true;
1263
1264         /* default to only allowing write access to owner of the mount */
1265         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1266
1267         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1268         /* default is always to request posix paths. */
1269         vol->posix_paths = 1;
1270         /* default to using server inode numbers where available */
1271         vol->server_ino = 1;
1272
1273         /* default is to use strict cifs caching semantics */
1274         vol->strict_io = true;
1275
1276         vol->actimeo = CIFS_DEF_ACTIMEO;
1277
1278         /* FIXME: add autonegotiation -- for now, SMB1 is default */
1279         vol->ops = &smb1_operations;
1280         vol->vals = &smb1_values;
1281
1282         if (!mountdata)
1283                 goto cifs_parse_mount_err;
1284
1285         mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1286         if (!mountdata_copy)
1287                 goto cifs_parse_mount_err;
1288
1289         options = mountdata_copy;
1290         end = options + strlen(options);
1291
1292         if (strncmp(options, "sep=", 4) == 0) {
1293                 if (options[4] != 0) {
1294                         separator[0] = options[4];
1295                         options += 5;
1296                 } else {
1297                         cifs_dbg(FYI, "Null separator not allowed\n");
1298                 }
1299         }
1300         vol->backupuid_specified = false; /* no backup intent for a user */
1301         vol->backupgid_specified = false; /* no backup intent for a group */
1302
1303         switch (cifs_parse_devname(devname, vol)) {
1304         case 0:
1305                 break;
1306         case -ENOMEM:
1307                 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1308                 goto cifs_parse_mount_err;
1309         case -EINVAL:
1310                 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1311                 goto cifs_parse_mount_err;
1312         default:
1313                 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1314                 goto cifs_parse_mount_err;
1315         }
1316
1317         while ((data = strsep(&options, separator)) != NULL) {
1318                 substring_t args[MAX_OPT_ARGS];
1319                 unsigned long option;
1320                 int token;
1321
1322                 if (!*data)
1323                         continue;
1324
1325                 token = match_token(data, cifs_mount_option_tokens, args);
1326
1327                 switch (token) {
1328
1329                 /* Ingnore the following */
1330                 case Opt_ignore:
1331                         break;
1332
1333                 /* Boolean values */
1334                 case Opt_user_xattr:
1335                         vol->no_xattr = 0;
1336                         break;
1337                 case Opt_nouser_xattr:
1338                         vol->no_xattr = 1;
1339                         break;
1340                 case Opt_forceuid:
1341                         override_uid = 1;
1342                         break;
1343                 case Opt_noforceuid:
1344                         override_uid = 0;
1345                         break;
1346                 case Opt_forcegid:
1347                         override_gid = 1;
1348                         break;
1349                 case Opt_noforcegid:
1350                         override_gid = 0;
1351                         break;
1352                 case Opt_noblocksend:
1353                         vol->noblocksnd = 1;
1354                         break;
1355                 case Opt_noautotune:
1356                         vol->noautotune = 1;
1357                         break;
1358                 case Opt_hard:
1359                         vol->retry = 1;
1360                         break;
1361                 case Opt_soft:
1362                         vol->retry = 0;
1363                         break;
1364                 case Opt_perm:
1365                         vol->noperm = 0;
1366                         break;
1367                 case Opt_noperm:
1368                         vol->noperm = 1;
1369                         break;
1370                 case Opt_mapchars:
1371                         vol->sfu_remap = true;
1372                         vol->remap = false; /* disable SFM mapping */
1373                         break;
1374                 case Opt_nomapchars:
1375                         vol->sfu_remap = false;
1376                         break;
1377                 case Opt_mapposix:
1378                         vol->remap = true;
1379                         vol->sfu_remap = false; /* disable SFU mapping */
1380                         break;
1381                 case Opt_nomapposix:
1382                         vol->remap = false;
1383                         break;
1384                 case Opt_sfu:
1385                         vol->sfu_emul = 1;
1386                         break;
1387                 case Opt_nosfu:
1388                         vol->sfu_emul = 0;
1389                         break;
1390                 case Opt_nodfs:
1391                         vol->nodfs = 1;
1392                         break;
1393                 case Opt_posixpaths:
1394                         vol->posix_paths = 1;
1395                         break;
1396                 case Opt_noposixpaths:
1397                         vol->posix_paths = 0;
1398                         break;
1399                 case Opt_nounix:
1400                         vol->no_linux_ext = 1;
1401                         break;
1402                 case Opt_nocase:
1403                         vol->nocase = 1;
1404                         break;
1405                 case Opt_brl:
1406                         vol->nobrl =  0;
1407                         break;
1408                 case Opt_nobrl:
1409                         vol->nobrl =  1;
1410                         /*
1411                          * turn off mandatory locking in mode
1412                          * if remote locking is turned off since the
1413                          * local vfs will do advisory
1414                          */
1415                         if (vol->file_mode ==
1416                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1417                                 vol->file_mode = S_IALLUGO;
1418                         break;
1419                 case Opt_forcemandatorylock:
1420                         vol->mand_lock = 1;
1421                         break;
1422                 case Opt_setuids:
1423                         vol->setuids = 1;
1424                         break;
1425                 case Opt_nosetuids:
1426                         vol->setuids = 0;
1427                         break;
1428                 case Opt_dynperm:
1429                         vol->dynperm = true;
1430                         break;
1431                 case Opt_nodynperm:
1432                         vol->dynperm = false;
1433                         break;
1434                 case Opt_nohard:
1435                         vol->retry = 0;
1436                         break;
1437                 case Opt_nosoft:
1438                         vol->retry = 1;
1439                         break;
1440                 case Opt_nointr:
1441                         vol->intr = 0;
1442                         break;
1443                 case Opt_intr:
1444                         vol->intr = 1;
1445                         break;
1446                 case Opt_nostrictsync:
1447                         vol->nostrictsync = 1;
1448                         break;
1449                 case Opt_strictsync:
1450                         vol->nostrictsync = 0;
1451                         break;
1452                 case Opt_serverino:
1453                         vol->server_ino = 1;
1454                         break;
1455                 case Opt_noserverino:
1456                         vol->server_ino = 0;
1457                         break;
1458                 case Opt_rwpidforward:
1459                         vol->rwpidforward = 1;
1460                         break;
1461                 case Opt_cifsacl:
1462                         vol->cifs_acl = 1;
1463                         break;
1464                 case Opt_nocifsacl:
1465                         vol->cifs_acl = 0;
1466                         break;
1467                 case Opt_acl:
1468                         vol->no_psx_acl = 0;
1469                         break;
1470                 case Opt_noacl:
1471                         vol->no_psx_acl = 1;
1472                         break;
1473                 case Opt_locallease:
1474                         vol->local_lease = 1;
1475                         break;
1476                 case Opt_sign:
1477                         vol->sign = true;
1478                         break;
1479                 case Opt_seal:
1480                         /* we do not do the following in secFlags because seal
1481                          * is a per tree connection (mount) not a per socket
1482                          * or per-smb connection option in the protocol
1483                          * vol->secFlg |= CIFSSEC_MUST_SEAL;
1484                          */
1485                         vol->seal = 1;
1486                         break;
1487                 case Opt_noac:
1488                         pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1489                         break;
1490                 case Opt_fsc:
1491 #ifndef CONFIG_CIFS_FSCACHE
1492                         cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1493                         goto cifs_parse_mount_err;
1494 #endif
1495                         vol->fsc = true;
1496                         break;
1497                 case Opt_mfsymlinks:
1498                         vol->mfsymlinks = true;
1499                         break;
1500                 case Opt_multiuser:
1501                         vol->multiuser = true;
1502                         break;
1503                 case Opt_sloppy:
1504                         sloppy = true;
1505                         break;
1506                 case Opt_nosharesock:
1507                         vol->nosharesock = true;
1508                         break;
1509                 case Opt_nopersistent:
1510                         vol->nopersistent = true;
1511                         if (vol->persistent) {
1512                                 cifs_dbg(VFS,
1513                                   "persistenthandles mount options conflict\n");
1514                                 goto cifs_parse_mount_err;
1515                         }
1516                         break;
1517                 case Opt_persistent:
1518                         vol->persistent = true;
1519                         if ((vol->nopersistent) || (vol->resilient)) {
1520                                 cifs_dbg(VFS,
1521                                   "persistenthandles mount options conflict\n");
1522                                 goto cifs_parse_mount_err;
1523                         }
1524                         break;
1525                 case Opt_resilient:
1526                         vol->resilient = true;
1527                         if (vol->persistent) {
1528                                 cifs_dbg(VFS,
1529                                   "persistenthandles mount options conflict\n");
1530                                 goto cifs_parse_mount_err;
1531                         }
1532                         break;
1533                 case Opt_noresilient:
1534                         vol->resilient = false; /* already the default */
1535                         break;
1536
1537                 /* Numeric Values */
1538                 case Opt_backupuid:
1539                         if (get_option_uid(args, &vol->backupuid)) {
1540                                 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1541                                          __func__);
1542                                 goto cifs_parse_mount_err;
1543                         }
1544                         vol->backupuid_specified = true;
1545                         break;
1546                 case Opt_backupgid:
1547                         if (get_option_gid(args, &vol->backupgid)) {
1548                                 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1549                                          __func__);
1550                                 goto cifs_parse_mount_err;
1551                         }
1552                         vol->backupgid_specified = true;
1553                         break;
1554                 case Opt_uid:
1555                         if (get_option_uid(args, &vol->linux_uid)) {
1556                                 cifs_dbg(VFS, "%s: Invalid uid value\n",
1557                                          __func__);
1558                                 goto cifs_parse_mount_err;
1559                         }
1560                         uid_specified = true;
1561                         break;
1562                 case Opt_cruid:
1563                         if (get_option_uid(args, &vol->cred_uid)) {
1564                                 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1565                                          __func__);
1566                                 goto cifs_parse_mount_err;
1567                         }
1568                         break;
1569                 case Opt_gid:
1570                         if (get_option_gid(args, &vol->linux_gid)) {
1571                                 cifs_dbg(VFS, "%s: Invalid gid value\n",
1572                                          __func__);
1573                                 goto cifs_parse_mount_err;
1574                         }
1575                         gid_specified = true;
1576                         break;
1577                 case Opt_file_mode:
1578                         if (get_option_ul(args, &option)) {
1579                                 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1580                                          __func__);
1581                                 goto cifs_parse_mount_err;
1582                         }
1583                         vol->file_mode = option;
1584                         break;
1585                 case Opt_dirmode:
1586                         if (get_option_ul(args, &option)) {
1587                                 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1588                                          __func__);
1589                                 goto cifs_parse_mount_err;
1590                         }
1591                         vol->dir_mode = option;
1592                         break;
1593                 case Opt_port:
1594                         if (get_option_ul(args, &option) ||
1595                             option > USHRT_MAX) {
1596                                 cifs_dbg(VFS, "%s: Invalid port value\n",
1597                                          __func__);
1598                                 goto cifs_parse_mount_err;
1599                         }
1600                         port = (unsigned short)option;
1601                         break;
1602                 case Opt_rsize:
1603                         if (get_option_ul(args, &option)) {
1604                                 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1605                                          __func__);
1606                                 goto cifs_parse_mount_err;
1607                         }
1608                         vol->rsize = option;
1609                         break;
1610                 case Opt_wsize:
1611                         if (get_option_ul(args, &option)) {
1612                                 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1613                                          __func__);
1614                                 goto cifs_parse_mount_err;
1615                         }
1616                         vol->wsize = option;
1617                         break;
1618                 case Opt_actimeo:
1619                         if (get_option_ul(args, &option)) {
1620                                 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1621                                          __func__);
1622                                 goto cifs_parse_mount_err;
1623                         }
1624                         vol->actimeo = HZ * option;
1625                         if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1626                                 cifs_dbg(VFS, "attribute cache timeout too large\n");
1627                                 goto cifs_parse_mount_err;
1628                         }
1629                         break;
1630                 case Opt_echo_interval:
1631                         if (get_option_ul(args, &option)) {
1632                                 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1633                                          __func__);
1634                                 goto cifs_parse_mount_err;
1635                         }
1636                         vol->echo_interval = option;
1637                         break;
1638
1639                 /* String Arguments */
1640
1641                 case Opt_blank_user:
1642                         /* null user, ie. anonymous authentication */
1643                         vol->nullauth = 1;
1644                         vol->username = NULL;
1645                         break;
1646                 case Opt_user:
1647                         string = match_strdup(args);
1648                         if (string == NULL)
1649                                 goto out_nomem;
1650
1651                         if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1652                                                         CIFS_MAX_USERNAME_LEN) {
1653                                 pr_warn("CIFS: username too long\n");
1654                                 goto cifs_parse_mount_err;
1655                         }
1656
1657                         kfree(vol->username);
1658                         vol->username = kstrdup(string, GFP_KERNEL);
1659                         if (!vol->username)
1660                                 goto cifs_parse_mount_err;
1661                         break;
1662                 case Opt_blank_pass:
1663                         /* passwords have to be handled differently
1664                          * to allow the character used for deliminator
1665                          * to be passed within them
1666                          */
1667
1668                         /*
1669                          * Check if this is a case where the  password
1670                          * starts with a delimiter
1671                          */
1672                         tmp_end = strchr(data, '=');
1673                         tmp_end++;
1674                         if (!(tmp_end < end && tmp_end[1] == delim)) {
1675                                 /* No it is not. Set the password to NULL */
1676                                 kfree(vol->password);
1677                                 vol->password = NULL;
1678                                 break;
1679                         }
1680                         /* Yes it is. Drop down to Opt_pass below.*/
1681                 case Opt_pass:
1682                         /* Obtain the value string */
1683                         value = strchr(data, '=');
1684                         value++;
1685
1686                         /* Set tmp_end to end of the string */
1687                         tmp_end = (char *) value + strlen(value);
1688
1689                         /* Check if following character is the deliminator
1690                          * If yes, we have encountered a double deliminator
1691                          * reset the NULL character to the deliminator
1692                          */
1693                         if (tmp_end < end && tmp_end[1] == delim) {
1694                                 tmp_end[0] = delim;
1695
1696                                 /* Keep iterating until we get to a single
1697                                  * deliminator OR the end
1698                                  */
1699                                 while ((tmp_end = strchr(tmp_end, delim))
1700                                         != NULL && (tmp_end[1] == delim)) {
1701                                                 tmp_end = (char *) &tmp_end[2];
1702                                 }
1703
1704                                 /* Reset var options to point to next element */
1705                                 if (tmp_end) {
1706                                         tmp_end[0] = '\0';
1707                                         options = (char *) &tmp_end[1];
1708                                 } else
1709                                         /* Reached the end of the mount option
1710                                          * string */
1711                                         options = end;
1712                         }
1713
1714                         kfree(vol->password);
1715                         /* Now build new password string */
1716                         temp_len = strlen(value);
1717                         vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1718                         if (vol->password == NULL) {
1719                                 pr_warn("CIFS: no memory for password\n");
1720                                 goto cifs_parse_mount_err;
1721                         }
1722
1723                         for (i = 0, j = 0; i < temp_len; i++, j++) {
1724                                 vol->password[j] = value[i];
1725                                 if ((value[i] == delim) &&
1726                                      value[i+1] == delim)
1727                                         /* skip the second deliminator */
1728                                         i++;
1729                         }
1730                         vol->password[j] = '\0';
1731                         break;
1732                 case Opt_blank_ip:
1733                         /* FIXME: should this be an error instead? */
1734                         got_ip = false;
1735                         break;
1736                 case Opt_ip:
1737                         string = match_strdup(args);
1738                         if (string == NULL)
1739                                 goto out_nomem;
1740
1741                         if (!cifs_convert_address(dstaddr, string,
1742                                         strlen(string))) {
1743                                 pr_err("CIFS: bad ip= option (%s).\n", string);
1744                                 goto cifs_parse_mount_err;
1745                         }
1746                         got_ip = true;
1747                         break;
1748                 case Opt_domain:
1749                         string = match_strdup(args);
1750                         if (string == NULL)
1751                                 goto out_nomem;
1752
1753                         if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1754                                         == CIFS_MAX_DOMAINNAME_LEN) {
1755                                 pr_warn("CIFS: domain name too long\n");
1756                                 goto cifs_parse_mount_err;
1757                         }
1758
1759                         kfree(vol->domainname);
1760                         vol->domainname = kstrdup(string, GFP_KERNEL);
1761                         if (!vol->domainname) {
1762                                 pr_warn("CIFS: no memory for domainname\n");
1763                                 goto cifs_parse_mount_err;
1764                         }
1765                         cifs_dbg(FYI, "Domain name set\n");
1766                         break;
1767                 case Opt_srcaddr:
1768                         string = match_strdup(args);
1769                         if (string == NULL)
1770                                 goto out_nomem;
1771
1772                         if (!cifs_convert_address(
1773                                         (struct sockaddr *)&vol->srcaddr,
1774                                         string, strlen(string))) {
1775                                 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1776                                         string);
1777                                 goto cifs_parse_mount_err;
1778                         }
1779                         break;
1780                 case Opt_iocharset:
1781                         string = match_strdup(args);
1782                         if (string == NULL)
1783                                 goto out_nomem;
1784
1785                         if (strnlen(string, 1024) >= 65) {
1786                                 pr_warn("CIFS: iocharset name too long.\n");
1787                                 goto cifs_parse_mount_err;
1788                         }
1789
1790                          if (strncasecmp(string, "default", 7) != 0) {
1791                                 kfree(vol->iocharset);
1792                                 vol->iocharset = kstrdup(string,
1793                                                          GFP_KERNEL);
1794                                 if (!vol->iocharset) {
1795                                         pr_warn("CIFS: no memory for charset\n");
1796                                         goto cifs_parse_mount_err;
1797                                 }
1798                         }
1799                         /* if iocharset not set then load_nls_default
1800                          * is used by caller
1801                          */
1802                          cifs_dbg(FYI, "iocharset set to %s\n", string);
1803                         break;
1804                 case Opt_netbiosname:
1805                         string = match_strdup(args);
1806                         if (string == NULL)
1807                                 goto out_nomem;
1808
1809                         memset(vol->source_rfc1001_name, 0x20,
1810                                 RFC1001_NAME_LEN);
1811                         /*
1812                          * FIXME: are there cases in which a comma can
1813                          * be valid in workstation netbios name (and
1814                          * need special handling)?
1815                          */
1816                         for (i = 0; i < RFC1001_NAME_LEN; i++) {
1817                                 /* don't ucase netbiosname for user */
1818                                 if (string[i] == 0)
1819                                         break;
1820                                 vol->source_rfc1001_name[i] = string[i];
1821                         }
1822                         /* The string has 16th byte zero still from
1823                          * set at top of the function
1824                          */
1825                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1826                                 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1827                         break;
1828                 case Opt_servern:
1829                         /* servernetbiosname specified override *SMBSERVER */
1830                         string = match_strdup(args);
1831                         if (string == NULL)
1832                                 goto out_nomem;
1833
1834                         /* last byte, type, is 0x20 for servr type */
1835                         memset(vol->target_rfc1001_name, 0x20,
1836                                 RFC1001_NAME_LEN_WITH_NULL);
1837
1838                         /* BB are there cases in which a comma can be
1839                            valid in this workstation netbios name
1840                            (and need special handling)? */
1841
1842                         /* user or mount helper must uppercase the
1843                            netbios name */
1844                         for (i = 0; i < 15; i++) {
1845                                 if (string[i] == 0)
1846                                         break;
1847                                 vol->target_rfc1001_name[i] = string[i];
1848                         }
1849                         /* The string has 16th byte zero still from
1850                            set at top of the function  */
1851                         if (i == RFC1001_NAME_LEN && string[i] != 0)
1852                                 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1853                         break;
1854                 case Opt_ver:
1855                         string = match_strdup(args);
1856                         if (string == NULL)
1857                                 goto out_nomem;
1858
1859                         if (strncasecmp(string, "1", 1) == 0) {
1860                                 /* This is the default */
1861                                 break;
1862                         }
1863                         /* For all other value, error */
1864                         pr_warn("CIFS: Invalid version specified\n");
1865                         goto cifs_parse_mount_err;
1866                 case Opt_vers:
1867                         string = match_strdup(args);
1868                         if (string == NULL)
1869                                 goto out_nomem;
1870
1871                         if (cifs_parse_smb_version(string, vol) != 0)
1872                                 goto cifs_parse_mount_err;
1873                         break;
1874                 case Opt_sec:
1875                         string = match_strdup(args);
1876                         if (string == NULL)
1877                                 goto out_nomem;
1878
1879                         if (cifs_parse_security_flavors(string, vol) != 0)
1880                                 goto cifs_parse_mount_err;
1881                         break;
1882                 case Opt_cache:
1883                         string = match_strdup(args);
1884                         if (string == NULL)
1885                                 goto out_nomem;
1886
1887                         if (cifs_parse_cache_flavor(string, vol) != 0)
1888                                 goto cifs_parse_mount_err;
1889                         break;
1890                 default:
1891                         /*
1892                          * An option we don't recognize. Save it off for later
1893                          * if we haven't already found one
1894                          */
1895                         if (!invalid)
1896                                 invalid = data;
1897                         break;
1898                 }
1899                 /* Free up any allocated string */
1900                 kfree(string);
1901                 string = NULL;
1902         }
1903
1904         if (!sloppy && invalid) {
1905                 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1906                 goto cifs_parse_mount_err;
1907         }
1908
1909 #ifndef CONFIG_KEYS
1910         /* Muliuser mounts require CONFIG_KEYS support */
1911         if (vol->multiuser) {
1912                 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1913                 goto cifs_parse_mount_err;
1914         }
1915 #endif
1916         if (!vol->UNC) {
1917                 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1918                 goto cifs_parse_mount_err;
1919         }
1920
1921         /* make sure UNC has a share name */
1922         if (!strchr(vol->UNC + 3, '\\')) {
1923                 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1924                 goto cifs_parse_mount_err;
1925         }
1926
1927         if (!got_ip) {
1928                 /* No ip= option specified? Try to get it from UNC */
1929                 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1930                                                 strlen(&vol->UNC[2]))) {
1931                         pr_err("Unable to determine destination address.\n");
1932                         goto cifs_parse_mount_err;
1933                 }
1934         }
1935
1936         /* set the port that we got earlier */
1937         cifs_set_port(dstaddr, port);
1938
1939         if (uid_specified)
1940                 vol->override_uid = override_uid;
1941         else if (override_uid == 1)
1942                 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1943
1944         if (gid_specified)
1945                 vol->override_gid = override_gid;
1946         else if (override_gid == 1)
1947                 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1948
1949         kfree(mountdata_copy);
1950         return 0;
1951
1952 out_nomem:
1953         pr_warn("Could not allocate temporary buffer\n");
1954 cifs_parse_mount_err:
1955         kfree(string);
1956         kfree(mountdata_copy);
1957         return 1;
1958 }
1959
1960 /** Returns true if srcaddr isn't specified and rhs isn't
1961  * specified, or if srcaddr is specified and
1962  * matches the IP address of the rhs argument.
1963  */
1964 static bool
1965 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1966 {
1967         switch (srcaddr->sa_family) {
1968         case AF_UNSPEC:
1969                 return (rhs->sa_family == AF_UNSPEC);
1970         case AF_INET: {
1971                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1972                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1973                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1974         }
1975         case AF_INET6: {
1976                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1977                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1978                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1979         }
1980         default:
1981                 WARN_ON(1);
1982                 return false; /* don't expect to be here */
1983         }
1984 }
1985
1986 /*
1987  * If no port is specified in addr structure, we try to match with 445 port
1988  * and if it fails - with 139 ports. It should be called only if address
1989  * families of server and addr are equal.
1990  */
1991 static bool
1992 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1993 {
1994         __be16 port, *sport;
1995
1996         switch (addr->sa_family) {
1997         case AF_INET:
1998                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1999                 port = ((struct sockaddr_in *) addr)->sin_port;
2000                 break;
2001         case AF_INET6:
2002                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2003                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2004                 break;
2005         default:
2006                 WARN_ON(1);
2007                 return false;
2008         }
2009
2010         if (!port) {
2011                 port = htons(CIFS_PORT);
2012                 if (port == *sport)
2013                         return true;
2014
2015                 port = htons(RFC1001_PORT);
2016         }
2017
2018         return port == *sport;
2019 }
2020
2021 static bool
2022 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2023               struct sockaddr *srcaddr)
2024 {
2025         switch (addr->sa_family) {
2026         case AF_INET: {
2027                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2028                 struct sockaddr_in *srv_addr4 =
2029                                         (struct sockaddr_in *)&server->dstaddr;
2030
2031                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2032                         return false;
2033                 break;
2034         }
2035         case AF_INET6: {
2036                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2037                 struct sockaddr_in6 *srv_addr6 =
2038                                         (struct sockaddr_in6 *)&server->dstaddr;
2039
2040                 if (!ipv6_addr_equal(&addr6->sin6_addr,
2041                                      &srv_addr6->sin6_addr))
2042                         return false;
2043                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2044                         return false;
2045                 break;
2046         }
2047         default:
2048                 WARN_ON(1);
2049                 return false; /* don't expect to be here */
2050         }
2051
2052         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2053                 return false;
2054
2055         return true;
2056 }
2057
2058 static bool
2059 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2060 {
2061         /*
2062          * The select_sectype function should either return the vol->sectype
2063          * that was specified, or "Unspecified" if that sectype was not
2064          * compatible with the given NEGOTIATE request.
2065          */
2066         if (select_sectype(server, vol->sectype) == Unspecified)
2067                 return false;
2068
2069         /*
2070          * Now check if signing mode is acceptable. No need to check
2071          * global_secflags at this point since if MUST_SIGN is set then
2072          * the server->sign had better be too.
2073          */
2074         if (vol->sign && !server->sign)
2075                 return false;
2076
2077         return true;
2078 }
2079
2080 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2081 {
2082         struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2083
2084         if (vol->nosharesock)
2085                 return 0;
2086
2087         if ((server->vals != vol->vals) || (server->ops != vol->ops))
2088                 return 0;
2089
2090         if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2091                 return 0;
2092
2093         if (!match_address(server, addr,
2094                            (struct sockaddr *)&vol->srcaddr))
2095                 return 0;
2096
2097         if (!match_port(server, addr))
2098                 return 0;
2099
2100         if (!match_security(server, vol))
2101                 return 0;
2102
2103         if (server->echo_interval != vol->echo_interval)
2104                 return 0;
2105
2106         return 1;
2107 }
2108
2109 static struct TCP_Server_Info *
2110 cifs_find_tcp_session(struct smb_vol *vol)
2111 {
2112         struct TCP_Server_Info *server;
2113
2114         spin_lock(&cifs_tcp_ses_lock);
2115         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2116                 if (!match_server(server, vol))
2117                         continue;
2118
2119                 ++server->srv_count;
2120                 spin_unlock(&cifs_tcp_ses_lock);
2121                 cifs_dbg(FYI, "Existing tcp session with server found\n");
2122                 return server;
2123         }
2124         spin_unlock(&cifs_tcp_ses_lock);
2125         return NULL;
2126 }
2127
2128 static void
2129 cifs_put_tcp_session(struct TCP_Server_Info *server)
2130 {
2131         struct task_struct *task;
2132
2133         spin_lock(&cifs_tcp_ses_lock);
2134         if (--server->srv_count > 0) {
2135                 spin_unlock(&cifs_tcp_ses_lock);
2136                 return;
2137         }
2138
2139         put_net(cifs_net_ns(server));
2140
2141         list_del_init(&server->tcp_ses_list);
2142         spin_unlock(&cifs_tcp_ses_lock);
2143
2144         cancel_delayed_work_sync(&server->echo);
2145
2146         spin_lock(&GlobalMid_Lock);
2147         server->tcpStatus = CifsExiting;
2148         spin_unlock(&GlobalMid_Lock);
2149
2150         cifs_crypto_shash_release(server);
2151         cifs_fscache_release_client_cookie(server);
2152
2153         kfree(server->session_key.response);
2154         server->session_key.response = NULL;
2155         server->session_key.len = 0;
2156
2157         task = xchg(&server->tsk, NULL);
2158         if (task)
2159                 force_sig(SIGKILL, task);
2160 }
2161
2162 static struct TCP_Server_Info *
2163 cifs_get_tcp_session(struct smb_vol *volume_info)
2164 {
2165         struct TCP_Server_Info *tcp_ses = NULL;
2166         int rc;
2167
2168         cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2169
2170         /* see if we already have a matching tcp_ses */
2171         tcp_ses = cifs_find_tcp_session(volume_info);
2172         if (tcp_ses)
2173                 return tcp_ses;
2174
2175         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2176         if (!tcp_ses) {
2177                 rc = -ENOMEM;
2178                 goto out_err;
2179         }
2180
2181         tcp_ses->ops = volume_info->ops;
2182         tcp_ses->vals = volume_info->vals;
2183         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2184         tcp_ses->hostname = extract_hostname(volume_info->UNC);
2185         if (IS_ERR(tcp_ses->hostname)) {
2186                 rc = PTR_ERR(tcp_ses->hostname);
2187                 goto out_err_crypto_release;
2188         }
2189
2190         tcp_ses->noblocksnd = volume_info->noblocksnd;
2191         tcp_ses->noautotune = volume_info->noautotune;
2192         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2193         tcp_ses->in_flight = 0;
2194         tcp_ses->credits = 1;
2195         init_waitqueue_head(&tcp_ses->response_q);
2196         init_waitqueue_head(&tcp_ses->request_q);
2197         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2198         mutex_init(&tcp_ses->srv_mutex);
2199         memcpy(tcp_ses->workstation_RFC1001_name,
2200                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2201         memcpy(tcp_ses->server_RFC1001_name,
2202                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2203         tcp_ses->session_estab = false;
2204         tcp_ses->sequence_number = 0;
2205         tcp_ses->lstrp = jiffies;
2206         spin_lock_init(&tcp_ses->req_lock);
2207         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2208         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2209         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2210         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2211                sizeof(tcp_ses->srcaddr));
2212         memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2213                 sizeof(tcp_ses->dstaddr));
2214 #ifdef CONFIG_CIFS_SMB2
2215         get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE);
2216 #endif
2217         /*
2218          * at this point we are the only ones with the pointer
2219          * to the struct since the kernel thread not created yet
2220          * no need to spinlock this init of tcpStatus or srv_count
2221          */
2222         tcp_ses->tcpStatus = CifsNew;
2223         ++tcp_ses->srv_count;
2224
2225         if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2226                 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2227                 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2228         else
2229                 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2230
2231         rc = ip_connect(tcp_ses);
2232         if (rc < 0) {
2233                 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2234                 goto out_err_crypto_release;
2235         }
2236
2237         /*
2238          * since we're in a cifs function already, we know that
2239          * this will succeed. No need for try_module_get().
2240          */
2241         __module_get(THIS_MODULE);
2242         tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2243                                   tcp_ses, "cifsd");
2244         if (IS_ERR(tcp_ses->tsk)) {
2245                 rc = PTR_ERR(tcp_ses->tsk);
2246                 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2247                 module_put(THIS_MODULE);
2248                 goto out_err_crypto_release;
2249         }
2250         tcp_ses->tcpStatus = CifsNeedNegotiate;
2251
2252         /* thread spawned, put it on the list */
2253         spin_lock(&cifs_tcp_ses_lock);
2254         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2255         spin_unlock(&cifs_tcp_ses_lock);
2256
2257         cifs_fscache_get_client_cookie(tcp_ses);
2258
2259         /* queue echo request delayed work */
2260         queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2261
2262         return tcp_ses;
2263
2264 out_err_crypto_release:
2265         cifs_crypto_shash_release(tcp_ses);
2266
2267         put_net(cifs_net_ns(tcp_ses));
2268
2269 out_err:
2270         if (tcp_ses) {
2271                 if (!IS_ERR(tcp_ses->hostname))
2272                         kfree(tcp_ses->hostname);
2273                 if (tcp_ses->ssocket)
2274                         sock_release(tcp_ses->ssocket);
2275                 kfree(tcp_ses);
2276         }
2277         return ERR_PTR(rc);
2278 }
2279
2280 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2281 {
2282         if (vol->sectype != Unspecified &&
2283             vol->sectype != ses->sectype)
2284                 return 0;
2285
2286         switch (ses->sectype) {
2287         case Kerberos:
2288                 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2289                         return 0;
2290                 break;
2291         default:
2292                 /* NULL username means anonymous session */
2293                 if (ses->user_name == NULL) {
2294                         if (!vol->nullauth)
2295                                 return 0;
2296                         break;
2297                 }
2298
2299                 /* anything else takes username/password */
2300                 if (strncmp(ses->user_name,
2301                             vol->username ? vol->username : "",
2302                             CIFS_MAX_USERNAME_LEN))
2303                         return 0;
2304                 if ((vol->username && strlen(vol->username) != 0) &&
2305                     ses->password != NULL &&
2306                     strncmp(ses->password,
2307                             vol->password ? vol->password : "",
2308                             CIFS_MAX_PASSWORD_LEN))
2309                         return 0;
2310         }
2311         return 1;
2312 }
2313
2314 static struct cifs_ses *
2315 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2316 {
2317         struct cifs_ses *ses;
2318
2319         spin_lock(&cifs_tcp_ses_lock);
2320         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2321                 if (ses->status == CifsExiting)
2322                         continue;
2323                 if (!match_session(ses, vol))
2324                         continue;
2325                 ++ses->ses_count;
2326                 spin_unlock(&cifs_tcp_ses_lock);
2327                 return ses;
2328         }
2329         spin_unlock(&cifs_tcp_ses_lock);
2330         return NULL;
2331 }
2332
2333 static void
2334 cifs_put_smb_ses(struct cifs_ses *ses)
2335 {
2336         unsigned int rc, xid;
2337         struct TCP_Server_Info *server = ses->server;
2338
2339         cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2340
2341         spin_lock(&cifs_tcp_ses_lock);
2342         if (ses->status == CifsExiting) {
2343                 spin_unlock(&cifs_tcp_ses_lock);
2344                 return;
2345         }
2346         if (--ses->ses_count > 0) {
2347                 spin_unlock(&cifs_tcp_ses_lock);
2348                 return;
2349         }
2350         if (ses->status == CifsGood)
2351                 ses->status = CifsExiting;
2352         spin_unlock(&cifs_tcp_ses_lock);
2353
2354         if (ses->status == CifsExiting && server->ops->logoff) {
2355                 xid = get_xid();
2356                 rc = server->ops->logoff(xid, ses);
2357                 if (rc)
2358                         cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2359                                 __func__, rc);
2360                 _free_xid(xid);
2361         }
2362
2363         spin_lock(&cifs_tcp_ses_lock);
2364         list_del_init(&ses->smb_ses_list);
2365         spin_unlock(&cifs_tcp_ses_lock);
2366
2367         sesInfoFree(ses);
2368         cifs_put_tcp_session(server);
2369 }
2370
2371 #ifdef CONFIG_KEYS
2372
2373 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2374 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2375
2376 /* Populate username and pw fields from keyring if possible */
2377 static int
2378 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2379 {
2380         int rc = 0;
2381         const char *delim, *payload;
2382         char *desc;
2383         ssize_t len;
2384         struct key *key;
2385         struct TCP_Server_Info *server = ses->server;
2386         struct sockaddr_in *sa;
2387         struct sockaddr_in6 *sa6;
2388         const struct user_key_payload *upayload;
2389
2390         desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2391         if (!desc)
2392                 return -ENOMEM;
2393
2394         /* try to find an address key first */
2395         switch (server->dstaddr.ss_family) {
2396         case AF_INET:
2397                 sa = (struct sockaddr_in *)&server->dstaddr;
2398                 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2399                 break;
2400         case AF_INET6:
2401                 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2402                 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2403                 break;
2404         default:
2405                 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2406                          server->dstaddr.ss_family);
2407                 rc = -EINVAL;
2408                 goto out_err;
2409         }
2410
2411         cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2412         key = request_key(&key_type_logon, desc, "");
2413         if (IS_ERR(key)) {
2414                 if (!ses->domainName) {
2415                         cifs_dbg(FYI, "domainName is NULL\n");
2416                         rc = PTR_ERR(key);
2417                         goto out_err;
2418                 }
2419
2420                 /* didn't work, try to find a domain key */
2421                 sprintf(desc, "cifs:d:%s", ses->domainName);
2422                 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2423                 key = request_key(&key_type_logon, desc, "");
2424                 if (IS_ERR(key)) {
2425                         rc = PTR_ERR(key);
2426                         goto out_err;
2427                 }
2428         }
2429
2430         down_read(&key->sem);
2431         upayload = user_key_payload(key);
2432         if (IS_ERR_OR_NULL(upayload)) {
2433                 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2434                 goto out_key_put;
2435         }
2436
2437         /* find first : in payload */
2438         payload = upayload->data;
2439         delim = strnchr(payload, upayload->datalen, ':');
2440         cifs_dbg(FYI, "payload=%s\n", payload);
2441         if (!delim) {
2442                 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2443                          upayload->datalen);
2444                 rc = -EINVAL;
2445                 goto out_key_put;
2446         }
2447
2448         len = delim - payload;
2449         if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2450                 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2451                          len);
2452                 rc = -EINVAL;
2453                 goto out_key_put;
2454         }
2455
2456         vol->username = kstrndup(payload, len, GFP_KERNEL);
2457         if (!vol->username) {
2458                 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2459                          len);
2460                 rc = -ENOMEM;
2461                 goto out_key_put;
2462         }
2463         cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2464
2465         len = key->datalen - (len + 1);
2466         if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2467                 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2468                 rc = -EINVAL;
2469                 kfree(vol->username);
2470                 vol->username = NULL;
2471                 goto out_key_put;
2472         }
2473
2474         ++delim;
2475         vol->password = kstrndup(delim, len, GFP_KERNEL);
2476         if (!vol->password) {
2477                 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2478                          len);
2479                 rc = -ENOMEM;
2480                 kfree(vol->username);
2481                 vol->username = NULL;
2482                 goto out_key_put;
2483         }
2484
2485 out_key_put:
2486         up_read(&key->sem);
2487         key_put(key);
2488 out_err:
2489         kfree(desc);
2490         cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2491         return rc;
2492 }
2493 #else /* ! CONFIG_KEYS */
2494 static inline int
2495 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2496                    struct cifs_ses *ses __attribute__((unused)))
2497 {
2498         return -ENOSYS;
2499 }
2500 #endif /* CONFIG_KEYS */
2501
2502 static struct cifs_ses *
2503 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2504 {
2505         int rc = -ENOMEM;
2506         unsigned int xid;
2507         struct cifs_ses *ses;
2508         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2509         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2510
2511         xid = get_xid();
2512
2513         ses = cifs_find_smb_ses(server, volume_info);
2514         if (ses) {
2515                 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2516                          ses->status);
2517
2518                 mutex_lock(&ses->session_mutex);
2519                 rc = cifs_negotiate_protocol(xid, ses);
2520                 if (rc) {
2521                         mutex_unlock(&ses->session_mutex);
2522                         /* problem -- put our ses reference */
2523                         cifs_put_smb_ses(ses);
2524                         free_xid(xid);
2525                         return ERR_PTR(rc);
2526                 }
2527                 if (ses->need_reconnect) {
2528                         cifs_dbg(FYI, "Session needs reconnect\n");
2529                         rc = cifs_setup_session(xid, ses,
2530                                                 volume_info->local_nls);
2531                         if (rc) {
2532                                 mutex_unlock(&ses->session_mutex);
2533                                 /* problem -- put our reference */
2534                                 cifs_put_smb_ses(ses);
2535                                 free_xid(xid);
2536                                 return ERR_PTR(rc);
2537                         }
2538                 }
2539                 mutex_unlock(&ses->session_mutex);
2540
2541                 /* existing SMB ses has a server reference already */
2542                 cifs_put_tcp_session(server);
2543                 free_xid(xid);
2544                 return ses;
2545         }
2546
2547         cifs_dbg(FYI, "Existing smb sess not found\n");
2548         ses = sesInfoAlloc();
2549         if (ses == NULL)
2550                 goto get_ses_fail;
2551
2552         /* new SMB session uses our server ref */
2553         ses->server = server;
2554         if (server->dstaddr.ss_family == AF_INET6)
2555                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2556         else
2557                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2558
2559         if (volume_info->username) {
2560                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2561                 if (!ses->user_name)
2562                         goto get_ses_fail;
2563         }
2564
2565         /* volume_info->password freed at unmount */
2566         if (volume_info->password) {
2567                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2568                 if (!ses->password)
2569                         goto get_ses_fail;
2570         }
2571         if (volume_info->domainname) {
2572                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2573                 if (!ses->domainName)
2574                         goto get_ses_fail;
2575         }
2576         ses->cred_uid = volume_info->cred_uid;
2577         ses->linux_uid = volume_info->linux_uid;
2578
2579         ses->sectype = volume_info->sectype;
2580         ses->sign = volume_info->sign;
2581
2582         mutex_lock(&ses->session_mutex);
2583         rc = cifs_negotiate_protocol(xid, ses);
2584         if (!rc)
2585                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2586         mutex_unlock(&ses->session_mutex);
2587         if (rc)
2588                 goto get_ses_fail;
2589
2590         /* success, put it on the list */
2591         spin_lock(&cifs_tcp_ses_lock);
2592         list_add(&ses->smb_ses_list, &server->smb_ses_list);
2593         spin_unlock(&cifs_tcp_ses_lock);
2594
2595         free_xid(xid);
2596         return ses;
2597
2598 get_ses_fail:
2599         sesInfoFree(ses);
2600         free_xid(xid);
2601         return ERR_PTR(rc);
2602 }
2603
2604 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2605 {
2606         if (tcon->tidStatus == CifsExiting)
2607                 return 0;
2608         if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2609                 return 0;
2610         return 1;
2611 }
2612
2613 static struct cifs_tcon *
2614 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2615 {
2616         struct list_head *tmp;
2617         struct cifs_tcon *tcon;
2618
2619         spin_lock(&cifs_tcp_ses_lock);
2620         list_for_each(tmp, &ses->tcon_list) {
2621                 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2622                 if (!match_tcon(tcon, unc))
2623                         continue;
2624                 ++tcon->tc_count;
2625                 spin_unlock(&cifs_tcp_ses_lock);
2626                 return tcon;
2627         }
2628         spin_unlock(&cifs_tcp_ses_lock);
2629         return NULL;
2630 }
2631
2632 static void
2633 cifs_put_tcon(struct cifs_tcon *tcon)
2634 {
2635         unsigned int xid;
2636         struct cifs_ses *ses = tcon->ses;
2637
2638         cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2639         spin_lock(&cifs_tcp_ses_lock);
2640         if (--tcon->tc_count > 0) {
2641                 spin_unlock(&cifs_tcp_ses_lock);
2642                 return;
2643         }
2644
2645         list_del_init(&tcon->tcon_list);
2646         spin_unlock(&cifs_tcp_ses_lock);
2647
2648         xid = get_xid();
2649         if (ses->server->ops->tree_disconnect)
2650                 ses->server->ops->tree_disconnect(xid, tcon);
2651         _free_xid(xid);
2652
2653         cifs_fscache_release_super_cookie(tcon);
2654         tconInfoFree(tcon);
2655         cifs_put_smb_ses(ses);
2656 }
2657
2658 static struct cifs_tcon *
2659 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2660 {
2661         int rc, xid;
2662         struct cifs_tcon *tcon;
2663
2664         tcon = cifs_find_tcon(ses, volume_info->UNC);
2665         if (tcon) {
2666                 cifs_dbg(FYI, "Found match on UNC path\n");
2667                 /* existing tcon already has a reference */
2668                 cifs_put_smb_ses(ses);
2669                 if (tcon->seal != volume_info->seal)
2670                         cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2671                 return tcon;
2672         }
2673
2674         if (!ses->server->ops->tree_connect) {
2675                 rc = -ENOSYS;
2676                 goto out_fail;
2677         }
2678
2679         tcon = tconInfoAlloc();
2680         if (tcon == NULL) {
2681                 rc = -ENOMEM;
2682                 goto out_fail;
2683         }
2684
2685         tcon->ses = ses;
2686         if (volume_info->password) {
2687                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2688                 if (!tcon->password) {
2689                         rc = -ENOMEM;
2690                         goto out_fail;
2691                 }
2692         }
2693
2694         /*
2695          * BB Do we need to wrap session_mutex around this TCon call and Unix
2696          * SetFS as we do on SessSetup and reconnect?
2697          */
2698         xid = get_xid();
2699         rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2700                                             volume_info->local_nls);
2701         free_xid(xid);
2702         cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2703         if (rc)
2704                 goto out_fail;
2705
2706         if (volume_info->nodfs) {
2707                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2708                 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2709         }
2710         tcon->seal = volume_info->seal;
2711         tcon->use_persistent = false;
2712         /* check if SMB2 or later, CIFS does not support persistent handles */
2713         if (volume_info->persistent) {
2714                 if (ses->server->vals->protocol_id == 0) {
2715                         cifs_dbg(VFS,
2716                              "SMB3 or later required for persistent handles\n");
2717                         rc = -EOPNOTSUPP;
2718                         goto out_fail;
2719 #ifdef CONFIG_CIFS_SMB2
2720                 } else if (ses->server->capabilities &
2721                            SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2722                         tcon->use_persistent = true;
2723                 else /* persistent handles requested but not supported */ {
2724                         cifs_dbg(VFS,
2725                                 "Persistent handles not supported on share\n");
2726                         rc = -EOPNOTSUPP;
2727                         goto out_fail;
2728 #endif /* CONFIG_CIFS_SMB2 */
2729                 }
2730 #ifdef CONFIG_CIFS_SMB2
2731         } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2732              && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2733              && (volume_info->nopersistent == false)) {
2734                 cifs_dbg(FYI, "enabling persistent handles\n");
2735                 tcon->use_persistent = true;
2736 #endif /* CONFIG_CIFS_SMB2 */
2737         } else if (volume_info->resilient) {
2738                 if (ses->server->vals->protocol_id == 0) {
2739                         cifs_dbg(VFS,
2740                              "SMB2.1 or later required for resilient handles\n");
2741                         rc = -EOPNOTSUPP;
2742                         goto out_fail;
2743                 }
2744                 tcon->use_resilient = true;
2745         }
2746
2747         /*
2748          * We can have only one retry value for a connection to a share so for
2749          * resources mounted more than once to the same server share the last
2750          * value passed in for the retry flag is used.
2751          */
2752         tcon->retry = volume_info->retry;
2753         tcon->nocase = volume_info->nocase;
2754         tcon->local_lease = volume_info->local_lease;
2755         INIT_LIST_HEAD(&tcon->pending_opens);
2756
2757         spin_lock(&cifs_tcp_ses_lock);
2758         list_add(&tcon->tcon_list, &ses->tcon_list);
2759         spin_unlock(&cifs_tcp_ses_lock);
2760
2761         cifs_fscache_get_super_cookie(tcon);
2762
2763         return tcon;
2764
2765 out_fail:
2766         tconInfoFree(tcon);
2767         return ERR_PTR(rc);
2768 }
2769
2770 void
2771 cifs_put_tlink(struct tcon_link *tlink)
2772 {
2773         if (!tlink || IS_ERR(tlink))
2774                 return;
2775
2776         if (!atomic_dec_and_test(&tlink->tl_count) ||
2777             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2778                 tlink->tl_time = jiffies;
2779                 return;
2780         }
2781
2782         if (!IS_ERR(tlink_tcon(tlink)))
2783                 cifs_put_tcon(tlink_tcon(tlink));
2784         kfree(tlink);
2785         return;
2786 }
2787
2788 static inline struct tcon_link *
2789 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2790 {
2791         return cifs_sb->master_tlink;
2792 }
2793
2794 static int
2795 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2796 {
2797         struct cifs_sb_info *old = CIFS_SB(sb);
2798         struct cifs_sb_info *new = mnt_data->cifs_sb;
2799
2800         if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2801                 return 0;
2802
2803         if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2804             (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2805                 return 0;
2806
2807         /*
2808          * We want to share sb only if we don't specify an r/wsize or
2809          * specified r/wsize is greater than or equal to existing one.
2810          */
2811         if (new->wsize && new->wsize < old->wsize)
2812                 return 0;
2813
2814         if (new->rsize && new->rsize < old->rsize)
2815                 return 0;
2816
2817         if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2818                 return 0;
2819
2820         if (old->mnt_file_mode != new->mnt_file_mode ||
2821             old->mnt_dir_mode != new->mnt_dir_mode)
2822                 return 0;
2823
2824         if (strcmp(old->local_nls->charset, new->local_nls->charset))
2825                 return 0;
2826
2827         if (old->actimeo != new->actimeo)
2828                 return 0;
2829
2830         return 1;
2831 }
2832
2833 int
2834 cifs_match_super(struct super_block *sb, void *data)
2835 {
2836         struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2837         struct smb_vol *volume_info;
2838         struct cifs_sb_info *cifs_sb;
2839         struct TCP_Server_Info *tcp_srv;
2840         struct cifs_ses *ses;
2841         struct cifs_tcon *tcon;
2842         struct tcon_link *tlink;
2843         int rc = 0;
2844
2845         spin_lock(&cifs_tcp_ses_lock);
2846         cifs_sb = CIFS_SB(sb);
2847         tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2848         if (IS_ERR(tlink)) {
2849                 spin_unlock(&cifs_tcp_ses_lock);
2850                 return rc;
2851         }
2852         tcon = tlink_tcon(tlink);
2853         ses = tcon->ses;
2854         tcp_srv = ses->server;
2855
2856         volume_info = mnt_data->vol;
2857
2858         if (!match_server(tcp_srv, volume_info) ||
2859             !match_session(ses, volume_info) ||
2860             !match_tcon(tcon, volume_info->UNC)) {
2861                 rc = 0;
2862                 goto out;
2863         }
2864
2865         rc = compare_mount_options(sb, mnt_data);
2866 out:
2867         spin_unlock(&cifs_tcp_ses_lock);
2868         cifs_put_tlink(tlink);
2869         return rc;
2870 }
2871
2872 int
2873 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2874              const struct nls_table *nls_codepage, unsigned int *num_referrals,
2875              struct dfs_info3_param **referrals, int remap)
2876 {
2877         char *temp_unc;
2878         int rc = 0;
2879
2880         if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2881                 return -ENOSYS;
2882
2883         *num_referrals = 0;
2884         *referrals = NULL;
2885
2886         if (ses->ipc_tid == 0) {
2887                 temp_unc = kmalloc(2 /* for slashes */ +
2888                         strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2889                                 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2890                 if (temp_unc == NULL)
2891                         return -ENOMEM;
2892                 temp_unc[0] = '\\';
2893                 temp_unc[1] = '\\';
2894                 strcpy(temp_unc + 2, ses->serverName);
2895                 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2896                 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2897                                                     nls_codepage);
2898                 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2899                 kfree(temp_unc);
2900         }
2901         if (rc == 0)
2902                 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2903                                                      referrals, num_referrals,
2904                                                      nls_codepage, remap);
2905         /*
2906          * BB - map targetUNCs to dfs_info3 structures, here or in
2907          * ses->server->ops->get_dfs_refer.
2908          */
2909
2910         return rc;
2911 }
2912
2913 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2914 static struct lock_class_key cifs_key[2];
2915 static struct lock_class_key cifs_slock_key[2];
2916
2917 static inline void
2918 cifs_reclassify_socket4(struct socket *sock)
2919 {
2920         struct sock *sk = sock->sk;
2921         BUG_ON(sock_owned_by_user(sk));
2922         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2923                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2924 }
2925
2926 static inline void
2927 cifs_reclassify_socket6(struct socket *sock)
2928 {
2929         struct sock *sk = sock->sk;
2930         BUG_ON(sock_owned_by_user(sk));
2931         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2932                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2933 }
2934 #else
2935 static inline void
2936 cifs_reclassify_socket4(struct socket *sock)
2937 {
2938 }
2939
2940 static inline void
2941 cifs_reclassify_socket6(struct socket *sock)
2942 {
2943 }
2944 #endif
2945
2946 /* See RFC1001 section 14 on representation of Netbios names */
2947 static void rfc1002mangle(char *target, char *source, unsigned int length)
2948 {
2949         unsigned int i, j;
2950
2951         for (i = 0, j = 0; i < (length); i++) {
2952                 /* mask a nibble at a time and encode */
2953                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2954                 target[j+1] = 'A' + (0x0F & source[i]);
2955                 j += 2;
2956         }
2957
2958 }
2959
2960 static int
2961 bind_socket(struct TCP_Server_Info *server)
2962 {
2963         int rc = 0;
2964         if (server->srcaddr.ss_family != AF_UNSPEC) {
2965                 /* Bind to the specified local IP address */
2966                 struct socket *socket = server->ssocket;
2967                 rc = socket->ops->bind(socket,
2968                                        (struct sockaddr *) &server->srcaddr,
2969                                        sizeof(server->srcaddr));
2970                 if (rc < 0) {
2971                         struct sockaddr_in *saddr4;
2972                         struct sockaddr_in6 *saddr6;
2973                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2974                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2975                         if (saddr6->sin6_family == AF_INET6)
2976                                 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2977                                          &saddr6->sin6_addr, rc);
2978                         else
2979                                 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2980                                          &saddr4->sin_addr.s_addr, rc);
2981                 }
2982         }
2983         return rc;
2984 }
2985
2986 static int
2987 ip_rfc1001_connect(struct TCP_Server_Info *server)
2988 {
2989         int rc = 0;
2990         /*
2991          * some servers require RFC1001 sessinit before sending
2992          * negprot - BB check reconnection in case where second
2993          * sessinit is sent but no second negprot
2994          */
2995         struct rfc1002_session_packet *ses_init_buf;
2996         struct smb_hdr *smb_buf;
2997         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2998                                GFP_KERNEL);
2999         if (ses_init_buf) {
3000                 ses_init_buf->trailer.session_req.called_len = 32;
3001
3002                 if (server->server_RFC1001_name &&
3003                     server->server_RFC1001_name[0] != 0)
3004                         rfc1002mangle(ses_init_buf->trailer.
3005                                       session_req.called_name,
3006                                       server->server_RFC1001_name,
3007                                       RFC1001_NAME_LEN_WITH_NULL);
3008                 else
3009                         rfc1002mangle(ses_init_buf->trailer.
3010                                       session_req.called_name,
3011                                       DEFAULT_CIFS_CALLED_NAME,
3012                                       RFC1001_NAME_LEN_WITH_NULL);
3013
3014                 ses_init_buf->trailer.session_req.calling_len = 32;
3015
3016                 /*
3017                  * calling name ends in null (byte 16) from old smb
3018                  * convention.
3019                  */
3020                 if (server->workstation_RFC1001_name[0] != 0)
3021                         rfc1002mangle(ses_init_buf->trailer.
3022                                       session_req.calling_name,
3023                                       server->workstation_RFC1001_name,
3024                                       RFC1001_NAME_LEN_WITH_NULL);
3025                 else
3026                         rfc1002mangle(ses_init_buf->trailer.
3027                                       session_req.calling_name,
3028                                       "LINUX_CIFS_CLNT",
3029                                       RFC1001_NAME_LEN_WITH_NULL);
3030
3031                 ses_init_buf->trailer.session_req.scope1 = 0;
3032                 ses_init_buf->trailer.session_req.scope2 = 0;
3033                 smb_buf = (struct smb_hdr *)ses_init_buf;
3034
3035                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3036                 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3037                 rc = smb_send(server, smb_buf, 0x44);
3038                 kfree(ses_init_buf);
3039                 /*
3040                  * RFC1001 layer in at least one server
3041                  * requires very short break before negprot
3042                  * presumably because not expecting negprot
3043                  * to follow so fast.  This is a simple
3044                  * solution that works without
3045                  * complicating the code and causes no
3046                  * significant slowing down on mount
3047                  * for everyone else
3048                  */
3049                 usleep_range(1000, 2000);
3050         }
3051         /*
3052          * else the negprot may still work without this
3053          * even though malloc failed
3054          */
3055
3056         return rc;
3057 }
3058
3059 static int
3060 generic_ip_connect(struct TCP_Server_Info *server)
3061 {
3062         int rc = 0;
3063         __be16 sport;
3064         int slen, sfamily;
3065         struct socket *socket = server->ssocket;
3066         struct sockaddr *saddr;
3067
3068         saddr = (struct sockaddr *) &server->dstaddr;
3069
3070         if (server->dstaddr.ss_family == AF_INET6) {
3071                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3072                 slen = sizeof(struct sockaddr_in6);
3073                 sfamily = AF_INET6;
3074         } else {
3075                 sport = ((struct sockaddr_in *) saddr)->sin_port;
3076                 slen = sizeof(struct sockaddr_in);
3077                 sfamily = AF_INET;
3078         }
3079
3080         if (socket == NULL) {
3081                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3082                                    IPPROTO_TCP, &socket, 1);
3083                 if (rc < 0) {
3084                         cifs_dbg(VFS, "Error %d creating socket\n", rc);
3085                         server->ssocket = NULL;
3086                         return rc;
3087                 }
3088
3089                 /* BB other socket options to set KEEPALIVE, NODELAY? */
3090                 cifs_dbg(FYI, "Socket created\n");
3091                 server->ssocket = socket;
3092                 socket->sk->sk_allocation = GFP_NOFS;
3093                 if (sfamily == AF_INET6)
3094                         cifs_reclassify_socket6(socket);
3095                 else
3096                         cifs_reclassify_socket4(socket);
3097         }
3098
3099         rc = bind_socket(server);
3100         if (rc < 0)
3101                 return rc;
3102
3103         /*
3104          * Eventually check for other socket options to change from
3105          * the default. sock_setsockopt not used because it expects
3106          * user space buffer
3107          */
3108         socket->sk->sk_rcvtimeo = 7 * HZ;
3109         socket->sk->sk_sndtimeo = 5 * HZ;
3110
3111         /* make the bufsizes depend on wsize/rsize and max requests */
3112         if (server->noautotune) {
3113                 if (socket->sk->sk_sndbuf < (200 * 1024))
3114                         socket->sk->sk_sndbuf = 200 * 1024;
3115                 if (socket->sk->sk_rcvbuf < (140 * 1024))
3116                         socket->sk->sk_rcvbuf = 140 * 1024;
3117         }
3118
3119         if (server->tcp_nodelay) {
3120                 int val = 1;
3121                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3122                                 (char *)&val, sizeof(val));
3123                 if (rc)
3124                         cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3125                                  rc);
3126         }
3127
3128         cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3129                  socket->sk->sk_sndbuf,
3130                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3131
3132         rc = socket->ops->connect(socket, saddr, slen, 0);
3133         if (rc < 0) {
3134                 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3135                 sock_release(socket);
3136                 server->ssocket = NULL;
3137                 return rc;
3138         }
3139
3140         if (sport == htons(RFC1001_PORT))
3141                 rc = ip_rfc1001_connect(server);
3142
3143         return rc;
3144 }
3145
3146 static int
3147 ip_connect(struct TCP_Server_Info *server)
3148 {
3149         __be16 *sport;
3150         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3151         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3152
3153         if (server->dstaddr.ss_family == AF_INET6)
3154                 sport = &addr6->sin6_port;
3155         else
3156                 sport = &addr->sin_port;
3157
3158         if (*sport == 0) {
3159                 int rc;
3160
3161                 /* try with 445 port at first */
3162                 *sport = htons(CIFS_PORT);
3163
3164                 rc = generic_ip_connect(server);
3165                 if (rc >= 0)
3166                         return rc;
3167
3168                 /* if it failed, try with 139 port */
3169                 *sport = htons(RFC1001_PORT);
3170         }
3171
3172         return generic_ip_connect(server);
3173 }
3174
3175 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3176                           struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3177 {
3178         /* if we are reconnecting then should we check to see if
3179          * any requested capabilities changed locally e.g. via
3180          * remount but we can not do much about it here
3181          * if they have (even if we could detect it by the following)
3182          * Perhaps we could add a backpointer to array of sb from tcon
3183          * or if we change to make all sb to same share the same
3184          * sb as NFS - then we only have one backpointer to sb.
3185          * What if we wanted to mount the server share twice once with
3186          * and once without posixacls or posix paths? */
3187         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3188
3189         if (vol_info && vol_info->no_linux_ext) {
3190                 tcon->fsUnixInfo.Capability = 0;
3191                 tcon->unix_ext = 0; /* Unix Extensions disabled */
3192                 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3193                 return;
3194         } else if (vol_info)
3195                 tcon->unix_ext = 1; /* Unix Extensions supported */
3196
3197         if (tcon->unix_ext == 0) {
3198                 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3199                 return;
3200         }
3201
3202         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3203                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3204                 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3205                 /* check for reconnect case in which we do not
3206                    want to change the mount behavior if we can avoid it */
3207                 if (vol_info == NULL) {
3208                         /* turn off POSIX ACL and PATHNAMES if not set
3209                            originally at mount time */
3210                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3211                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3212                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3213                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3214                                         cifs_dbg(VFS, "POSIXPATH support change\n");
3215                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3216                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3217                                 cifs_dbg(VFS, "possible reconnect error\n");
3218                                 cifs_dbg(VFS, "server disabled POSIX path support\n");
3219                         }
3220                 }
3221
3222                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3223                         cifs_dbg(VFS, "per-share encryption not supported yet\n");
3224
3225                 cap &= CIFS_UNIX_CAP_MASK;
3226                 if (vol_info && vol_info->no_psx_acl)
3227                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3228                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3229                         cifs_dbg(FYI, "negotiated posix acl support\n");
3230                         if (cifs_sb)
3231                                 cifs_sb->mnt_cifs_flags |=
3232                                         CIFS_MOUNT_POSIXACL;
3233                 }
3234
3235                 if (vol_info && vol_info->posix_paths == 0)
3236                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3237                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3238                         cifs_dbg(FYI, "negotiate posix pathnames\n");
3239                         if (cifs_sb)
3240                                 cifs_sb->mnt_cifs_flags |=
3241                                         CIFS_MOUNT_POSIX_PATHS;
3242                 }
3243
3244                 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3245 #ifdef CONFIG_CIFS_DEBUG2
3246                 if (cap & CIFS_UNIX_FCNTL_CAP)
3247                         cifs_dbg(FYI, "FCNTL cap\n");
3248                 if (cap & CIFS_UNIX_EXTATTR_CAP)
3249                         cifs_dbg(FYI, "EXTATTR cap\n");
3250                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3251                         cifs_dbg(FYI, "POSIX path cap\n");
3252                 if (cap & CIFS_UNIX_XATTR_CAP)
3253                         cifs_dbg(FYI, "XATTR cap\n");
3254                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3255                         cifs_dbg(FYI, "POSIX ACL cap\n");
3256                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3257                         cifs_dbg(FYI, "very large read cap\n");
3258                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3259                         cifs_dbg(FYI, "very large write cap\n");
3260                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3261                         cifs_dbg(FYI, "transport encryption cap\n");
3262                 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3263                         cifs_dbg(FYI, "mandatory transport encryption cap\n");
3264 #endif /* CIFS_DEBUG2 */
3265                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3266                         if (vol_info == NULL) {
3267                                 cifs_dbg(FYI, "resetting capabilities failed\n");
3268                         } else
3269                                 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");
3270
3271                 }
3272         }
3273 }
3274
3275 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3276                         struct cifs_sb_info *cifs_sb)
3277 {
3278         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3279
3280         spin_lock_init(&cifs_sb->tlink_tree_lock);
3281         cifs_sb->tlink_tree = RB_ROOT;
3282
3283         /*
3284          * Temporarily set r/wsize for matching superblock. If we end up using
3285          * new sb then client will later negotiate it downward if needed.
3286          */
3287         cifs_sb->rsize = pvolume_info->rsize;
3288         cifs_sb->wsize = pvolume_info->wsize;
3289
3290         cifs_sb->mnt_uid = pvolume_info->linux_uid;
3291         cifs_sb->mnt_gid = pvolume_info->linux_gid;
3292         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3293         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3294         cifs_dbg(FYI, "file mode: 0x%hx  dir mode: 0x%hx\n",
3295                  cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3296
3297         cifs_sb->actimeo = pvolume_info->actimeo;
3298         cifs_sb->local_nls = pvolume_info->local_nls;
3299
3300         if (pvolume_info->noperm)
3301                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3302         if (pvolume_info->setuids)
3303                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3304         if (pvolume_info->server_ino)
3305                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3306         if (pvolume_info->remap)
3307                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3308         if (pvolume_info->sfu_remap)
3309                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3310         if (pvolume_info->no_xattr)
3311                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3312         if (pvolume_info->sfu_emul)
3313                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3314         if (pvolume_info->nobrl)
3315                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3316         if (pvolume_info->nostrictsync)
3317                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3318         if (pvolume_info->mand_lock)
3319                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3320         if (pvolume_info->rwpidforward)
3321                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3322         if (pvolume_info->cifs_acl)
3323                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3324         if (pvolume_info->backupuid_specified) {
3325                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3326                 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3327         }
3328         if (pvolume_info->backupgid_specified) {
3329                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3330                 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3331         }
3332         if (pvolume_info->override_uid)
3333                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3334         if (pvolume_info->override_gid)
3335                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3336         if (pvolume_info->dynperm)
3337                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3338         if (pvolume_info->fsc)
3339                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3340         if (pvolume_info->multiuser)
3341                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3342                                             CIFS_MOUNT_NO_PERM);
3343         if (pvolume_info->strict_io)
3344                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3345         if (pvolume_info->direct_io) {
3346                 cifs_dbg(FYI, "mounting share using direct i/o\n");
3347                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3348         }
3349         if (pvolume_info->mfsymlinks) {
3350                 if (pvolume_info->sfu_emul) {
3351                         /*
3352                          * Our SFU ("Services for Unix" emulation does not allow
3353                          * creating symlinks but does allow reading existing SFU
3354                          * symlinks (it does allow both creating and reading SFU
3355                          * style mknod and FIFOs though). When "mfsymlinks" and
3356                          * "sfu" are both enabled at the same time, it allows
3357                          * reading both types of symlinks, but will only create
3358                          * them with mfsymlinks format. This allows better
3359                          * Apple compatibility (probably better for Samba too)
3360                          * while still recognizing old Windows style symlinks.
3361                          */
3362                         cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3363                 }
3364                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3365         }
3366
3367         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3368                 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3369 }
3370
3371 static void
3372 cleanup_volume_info_contents(struct smb_vol *volume_info)
3373 {
3374         kfree(volume_info->username);
3375         kzfree(volume_info->password);
3376         kfree(volume_info->UNC);
3377         kfree(volume_info->domainname);
3378         kfree(volume_info->iocharset);
3379         kfree(volume_info->prepath);
3380 }
3381
3382 void
3383 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3384 {
3385         if (!volume_info)
3386                 return;
3387         cleanup_volume_info_contents(volume_info);
3388         kfree(volume_info);
3389 }
3390
3391
3392 #ifdef CONFIG_CIFS_DFS_UPCALL
3393 /*
3394  * cifs_build_path_to_root returns full path to root when we do not have an
3395  * exiting connection (tcon)
3396  */
3397 static char *
3398 build_unc_path_to_root(const struct smb_vol *vol,
3399                 const struct cifs_sb_info *cifs_sb)
3400 {
3401         char *full_path, *pos;
3402         unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3403         unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3404
3405         full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3406         if (full_path == NULL)
3407                 return ERR_PTR(-ENOMEM);
3408
3409         strncpy(full_path, vol->UNC, unc_len);
3410         pos = full_path + unc_len;
3411
3412         if (pplen) {
3413                 *pos = CIFS_DIR_SEP(cifs_sb);
3414                 strncpy(pos + 1, vol->prepath, pplen);
3415                 pos += pplen;
3416         }
3417
3418         *pos = '\0'; /* add trailing null */
3419         convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3420         cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3421         return full_path;
3422 }
3423
3424 /*
3425  * Perform a dfs referral query for a share and (optionally) prefix
3426  *
3427  * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3428  * to a string containing updated options for the submount.  Otherwise it
3429  * will be left untouched.
3430  *
3431  * Returns the rc from get_dfs_path to the caller, which can be used to
3432  * determine whether there were referrals.
3433  */
3434 static int
3435 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3436                     struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3437                     int check_prefix)
3438 {
3439         int rc;
3440         unsigned int num_referrals = 0;
3441         struct dfs_info3_param *referrals = NULL;
3442         char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3443
3444         full_path = build_unc_path_to_root(volume_info, cifs_sb);
3445         if (IS_ERR(full_path))
3446                 return PTR_ERR(full_path);
3447
3448         /* For DFS paths, skip the first '\' of the UNC */
3449         ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3450
3451         rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3452                           &num_referrals, &referrals, cifs_remap(cifs_sb));
3453
3454         if (!rc && num_referrals > 0) {
3455                 char *fake_devname = NULL;
3456
3457                 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3458                                                    full_path + 1, referrals,
3459                                                    &fake_devname);
3460
3461                 free_dfs_info_array(referrals, num_referrals);
3462
3463                 if (IS_ERR(mdata)) {
3464                         rc = PTR_ERR(mdata);
3465                         mdata = NULL;
3466                 } else {
3467                         cleanup_volume_info_contents(volume_info);
3468                         rc = cifs_setup_volume_info(volume_info, mdata,
3469                                                         fake_devname);
3470                 }
3471                 kfree(fake_devname);
3472                 kfree(cifs_sb->mountdata);
3473                 cifs_sb->mountdata = mdata;
3474         }
3475         kfree(full_path);
3476         return rc;
3477 }
3478 #endif
3479
3480 static int
3481 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3482                         const char *devname)
3483 {
3484         int rc = 0;
3485
3486         if (cifs_parse_mount_options(mount_data, devname, volume_info))
3487                 return -EINVAL;
3488
3489         if (volume_info->nullauth) {
3490                 cifs_dbg(FYI, "Anonymous login\n");
3491                 kfree(volume_info->username);
3492                 volume_info->username = NULL;
3493         } else if (volume_info->username) {
3494                 /* BB fixme parse for domain name here */
3495                 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3496         } else {
3497                 cifs_dbg(VFS, "No username specified\n");
3498         /* In userspace mount helper we can get user name from alternate
3499            locations such as env variables and files on disk */
3500                 return -EINVAL;
3501         }
3502
3503         /* this is needed for ASCII cp to Unicode converts */
3504         if (volume_info->iocharset == NULL) {
3505                 /* load_nls_default cannot return null */
3506                 volume_info->local_nls = load_nls_default();
3507         } else {
3508                 volume_info->local_nls = load_nls(volume_info->iocharset);
3509                 if (volume_info->local_nls == NULL) {
3510                         cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3511                                  volume_info->iocharset);
3512                         return -ELIBACC;
3513                 }
3514         }
3515
3516         return rc;
3517 }
3518
3519 struct smb_vol *
3520 cifs_get_volume_info(char *mount_data, const char *devname)
3521 {
3522         int rc;
3523         struct smb_vol *volume_info;
3524
3525         volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3526         if (!volume_info)
3527                 return ERR_PTR(-ENOMEM);
3528
3529         rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3530         if (rc) {
3531                 cifs_cleanup_volume_info(volume_info);
3532                 volume_info = ERR_PTR(rc);
3533         }
3534
3535         return volume_info;
3536 }
3537
3538 int
3539 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3540 {
3541         int rc;
3542         unsigned int xid;
3543         struct cifs_ses *ses;
3544         struct cifs_tcon *tcon;
3545         struct TCP_Server_Info *server;
3546         char   *full_path;
3547         struct tcon_link *tlink;
3548 #ifdef CONFIG_CIFS_DFS_UPCALL
3549         int referral_walks_count = 0;
3550 #endif
3551
3552         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3553         if (rc)
3554                 return rc;
3555
3556 #ifdef CONFIG_CIFS_DFS_UPCALL
3557 try_mount_again:
3558         /* cleanup activities if we're chasing a referral */
3559         if (referral_walks_count) {
3560                 if (tcon)
3561                         cifs_put_tcon(tcon);
3562                 else if (ses)
3563                         cifs_put_smb_ses(ses);
3564
3565                 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3566
3567                 free_xid(xid);
3568         }
3569 #endif
3570         rc = 0;
3571         tcon = NULL;
3572         ses = NULL;
3573         server = NULL;
3574         full_path = NULL;
3575         tlink = NULL;
3576
3577         xid = get_xid();
3578
3579         /* get a reference to a tcp session */
3580         server = cifs_get_tcp_session(volume_info);
3581         if (IS_ERR(server)) {
3582                 rc = PTR_ERR(server);
3583                 bdi_destroy(&cifs_sb->bdi);
3584                 goto out;
3585         }
3586
3587         /* get a reference to a SMB session */
3588         ses = cifs_get_smb_ses(server, volume_info);
3589         if (IS_ERR(ses)) {
3590                 rc = PTR_ERR(ses);
3591                 ses = NULL;
3592                 goto mount_fail_check;
3593         }
3594
3595 #ifdef CONFIG_CIFS_SMB2
3596         if ((volume_info->persistent == true) && ((ses->server->capabilities &
3597                 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3598                 cifs_dbg(VFS, "persistent handles not supported by server\n");
3599                 rc = -EOPNOTSUPP;
3600                 goto mount_fail_check;
3601         }
3602 #endif /* CONFIG_CIFS_SMB2*/
3603
3604         /* search for existing tcon to this server share */
3605         tcon = cifs_get_tcon(ses, volume_info);
3606         if (IS_ERR(tcon)) {
3607                 rc = PTR_ERR(tcon);
3608                 tcon = NULL;
3609                 goto remote_path_check;
3610         }
3611
3612         /* tell server which Unix caps we support */
3613         if (cap_unix(tcon->ses)) {
3614                 /* reset of caps checks mount to see if unix extensions
3615                    disabled for just this mount */
3616                 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3617                 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3618                     (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3619                      CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3620                         rc = -EACCES;
3621                         goto mount_fail_check;
3622                 }
3623         } else
3624                 tcon->unix_ext = 0; /* server does not support them */
3625
3626         /* do not care if a following call succeed - informational */
3627         if (!tcon->ipc && server->ops->qfs_tcon)
3628                 server->ops->qfs_tcon(xid, tcon);
3629
3630         cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3631         cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3632
3633         /* tune readahead according to rsize */
3634         cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3635
3636 remote_path_check:
3637 #ifdef CONFIG_CIFS_DFS_UPCALL
3638         /*
3639          * Perform an unconditional check for whether there are DFS
3640          * referrals for this path without prefix, to provide support
3641          * for DFS referrals from w2k8 servers which don't seem to respond
3642          * with PATH_NOT_COVERED to requests that include the prefix.
3643          * Chase the referral if found, otherwise continue normally.
3644          */
3645         if (referral_walks_count == 0) {
3646                 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3647                                                 false);
3648                 if (!refrc) {
3649                         referral_walks_count++;
3650                         goto try_mount_again;
3651                 }
3652         }
3653 #endif
3654
3655         /* check if a whole path is not remote */
3656         if (!rc && tcon) {
3657                 if (!server->ops->is_path_accessible) {
3658                         rc = -ENOSYS;
3659                         goto mount_fail_check;
3660                 }
3661                 /*
3662                  * cifs_build_path_to_root works only when we have a valid tcon
3663                  */
3664                 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3665                 if (full_path == NULL) {
3666                         rc = -ENOMEM;
3667                         goto mount_fail_check;
3668                 }
3669                 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3670                                                      full_path);
3671                 if (rc != 0 && rc != -EREMOTE) {
3672                         kfree(full_path);
3673                         goto mount_fail_check;
3674                 }
3675                 kfree(full_path);
3676         }
3677
3678         /* get referral if needed */
3679         if (rc == -EREMOTE) {
3680 #ifdef CONFIG_CIFS_DFS_UPCALL
3681                 if (referral_walks_count > MAX_NESTED_LINKS) {
3682                         /*
3683                          * BB: when we implement proper loop detection,
3684                          *     we will remove this check. But now we need it
3685                          *     to prevent an indefinite loop if 'DFS tree' is
3686                          *     misconfigured (i.e. has loops).
3687                          */
3688                         rc = -ELOOP;
3689                         goto mount_fail_check;
3690                 }
3691
3692                 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3693
3694                 if (!rc) {
3695                         referral_walks_count++;
3696                         goto try_mount_again;
3697                 }
3698                 goto mount_fail_check;
3699 #else /* No DFS support, return error on mount */
3700                 rc = -EOPNOTSUPP;
3701 #endif
3702         }
3703
3704         if (rc)
3705                 goto mount_fail_check;
3706
3707         /* now, hang the tcon off of the superblock */
3708         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3709         if (tlink == NULL) {
3710                 rc = -ENOMEM;
3711                 goto mount_fail_check;
3712         }
3713
3714         tlink->tl_uid = ses->linux_uid;
3715         tlink->tl_tcon = tcon;
3716         tlink->tl_time = jiffies;
3717         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3718         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3719
3720         cifs_sb->master_tlink = tlink;
3721         spin_lock(&cifs_sb->tlink_tree_lock);
3722         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3723         spin_unlock(&cifs_sb->tlink_tree_lock);
3724
3725         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3726                                 TLINK_IDLE_EXPIRE);
3727
3728 mount_fail_check:
3729         /* on error free sesinfo and tcon struct if needed */
3730         if (rc) {
3731                 /* If find_unc succeeded then rc == 0 so we can not end */
3732                 /* up accidentally freeing someone elses tcon struct */
3733                 if (tcon)
3734                         cifs_put_tcon(tcon);
3735                 else if (ses)
3736                         cifs_put_smb_ses(ses);
3737                 else
3738                         cifs_put_tcp_session(server);
3739                 bdi_destroy(&cifs_sb->bdi);
3740         }
3741
3742 out:
3743         free_xid(xid);
3744         return rc;
3745 }
3746
3747 /*
3748  * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3749  * pointer may be NULL.
3750  */
3751 int
3752 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3753          const char *tree, struct cifs_tcon *tcon,
3754          const struct nls_table *nls_codepage)
3755 {
3756         struct smb_hdr *smb_buffer;
3757         struct smb_hdr *smb_buffer_response;
3758         TCONX_REQ *pSMB;
3759         TCONX_RSP *pSMBr;
3760         unsigned char *bcc_ptr;
3761         int rc = 0;
3762         int length;
3763         __u16 bytes_left, count;
3764
3765         if (ses == NULL)
3766                 return -EIO;
3767
3768         smb_buffer = cifs_buf_get();
3769         if (smb_buffer == NULL)
3770                 return -ENOMEM;
3771
3772         smb_buffer_response = smb_buffer;
3773
3774         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3775                         NULL /*no tid */ , 4 /*wct */ );
3776
3777         smb_buffer->Mid = get_next_mid(ses->server);
3778         smb_buffer->Uid = ses->Suid;
3779         pSMB = (TCONX_REQ *) smb_buffer;
3780         pSMBr = (TCONX_RSP *) smb_buffer_response;
3781
3782         pSMB->AndXCommand = 0xFF;
3783         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3784         bcc_ptr = &pSMB->Password[0];
3785         if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3786                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
3787                 *bcc_ptr = 0; /* password is null byte */
3788                 bcc_ptr++;              /* skip password */
3789                 /* already aligned so no need to do it below */
3790         } else {
3791                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3792                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3793                    specified as required (when that support is added to
3794                    the vfs in the future) as only NTLM or the much
3795                    weaker LANMAN (which we do not send by default) is accepted
3796                    by Samba (not sure whether other servers allow
3797                    NTLMv2 password here) */
3798 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3799                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3800                     (ses->sectype == LANMAN))
3801                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3802                                          ses->server->sec_mode &
3803                                             SECMODE_PW_ENCRYPT ? true : false,
3804                                          bcc_ptr);
3805                 else
3806 #endif /* CIFS_WEAK_PW_HASH */
3807                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3808                                         bcc_ptr, nls_codepage);
3809                 if (rc) {
3810                         cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3811                                  __func__, rc);
3812                         cifs_buf_release(smb_buffer);
3813                         return rc;
3814                 }
3815
3816                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3817                 if (ses->capabilities & CAP_UNICODE) {
3818                         /* must align unicode strings */
3819                         *bcc_ptr = 0; /* null byte password */
3820                         bcc_ptr++;
3821                 }
3822         }
3823
3824         if (ses->server->sign)
3825                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3826
3827         if (ses->capabilities & CAP_STATUS32) {
3828                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3829         }
3830         if (ses->capabilities & CAP_DFS) {
3831                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3832         }
3833         if (ses->capabilities & CAP_UNICODE) {
3834                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3835                 length =
3836                     cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3837                         6 /* max utf8 char length in bytes */ *
3838                         (/* server len*/ + 256 /* share len */), nls_codepage);
3839                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3840                 bcc_ptr += 2;   /* skip trailing null */
3841         } else {                /* ASCII */
3842                 strcpy(bcc_ptr, tree);
3843                 bcc_ptr += strlen(tree) + 1;
3844         }
3845         strcpy(bcc_ptr, "?????");
3846         bcc_ptr += strlen("?????");
3847         bcc_ptr += 1;
3848         count = bcc_ptr - &pSMB->Password[0];
3849         pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3850                                         pSMB->hdr.smb_buf_length) + count);
3851         pSMB->ByteCount = cpu_to_le16(count);
3852
3853         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3854                          0);
3855
3856         /* above now done in SendReceive */
3857         if ((rc == 0) && (tcon != NULL)) {
3858                 bool is_unicode;
3859
3860                 tcon->tidStatus = CifsGood;
3861                 tcon->need_reconnect = false;
3862                 tcon->tid = smb_buffer_response->Tid;
3863                 bcc_ptr = pByteArea(smb_buffer_response);
3864                 bytes_left = get_bcc(smb_buffer_response);
3865                 length = strnlen(bcc_ptr, bytes_left - 2);
3866                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3867                         is_unicode = true;
3868                 else
3869                         is_unicode = false;
3870
3871
3872                 /* skip service field (NB: this field is always ASCII) */
3873                 if (length == 3) {
3874                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3875                             (bcc_ptr[2] == 'C')) {
3876                                 cifs_dbg(FYI, "IPC connection\n");
3877                                 tcon->ipc = 1;
3878                         }
3879                 } else if (length == 2) {
3880                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3881                                 /* the most common case */
3882                                 cifs_dbg(FYI, "disk share connection\n");
3883                         }
3884                 }
3885                 bcc_ptr += length + 1;
3886                 bytes_left -= (length + 1);
3887                 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3888
3889                 /* mostly informational -- no need to fail on error here */
3890                 kfree(tcon->nativeFileSystem);
3891                 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3892                                                       bytes_left, is_unicode,
3893                                                       nls_codepage);
3894
3895                 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3896
3897                 if ((smb_buffer_response->WordCount == 3) ||
3898                          (smb_buffer_response->WordCount == 7))
3899                         /* field is in same location */
3900                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3901                 else
3902                         tcon->Flags = 0;
3903                 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3904         } else if ((rc == 0) && tcon == NULL) {
3905                 /* all we need to save for IPC$ connection */
3906                 ses->ipc_tid = smb_buffer_response->Tid;
3907         }
3908
3909         cifs_buf_release(smb_buffer);
3910         return rc;
3911 }
3912
3913 static void delayed_free(struct rcu_head *p)
3914 {
3915         struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3916         unload_nls(sbi->local_nls);
3917         kfree(sbi);
3918 }
3919
3920 void
3921 cifs_umount(struct cifs_sb_info *cifs_sb)
3922 {
3923         struct rb_root *root = &cifs_sb->tlink_tree;
3924         struct rb_node *node;
3925         struct tcon_link *tlink;
3926
3927         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3928
3929         spin_lock(&cifs_sb->tlink_tree_lock);
3930         while ((node = rb_first(root))) {
3931                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3932                 cifs_get_tlink(tlink);
3933                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3934                 rb_erase(node, root);
3935
3936                 spin_unlock(&cifs_sb->tlink_tree_lock);
3937                 cifs_put_tlink(tlink);
3938                 spin_lock(&cifs_sb->tlink_tree_lock);
3939         }
3940         spin_unlock(&cifs_sb->tlink_tree_lock);
3941
3942         bdi_destroy(&cifs_sb->bdi);
3943         kfree(cifs_sb->mountdata);
3944         call_rcu(&cifs_sb->rcu, delayed_free);
3945 }
3946
3947 int
3948 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3949 {
3950         int rc = 0;
3951         struct TCP_Server_Info *server = ses->server;
3952
3953         if (!server->ops->need_neg || !server->ops->negotiate)
3954                 return -ENOSYS;
3955
3956         /* only send once per connect */
3957         if (!server->ops->need_neg(server))
3958                 return 0;
3959
3960         set_credits(server, 1);
3961
3962         rc = server->ops->negotiate(xid, ses);
3963         if (rc == 0) {
3964                 spin_lock(&GlobalMid_Lock);
3965                 if (server->tcpStatus == CifsNeedNegotiate)
3966                         server->tcpStatus = CifsGood;
3967                 else
3968                         rc = -EHOSTDOWN;
3969                 spin_unlock(&GlobalMid_Lock);
3970         }
3971
3972         return rc;
3973 }
3974
3975 int
3976 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3977                    struct nls_table *nls_info)
3978 {
3979         int rc = -ENOSYS;
3980         struct TCP_Server_Info *server = ses->server;
3981
3982         ses->capabilities = server->capabilities;
3983         if (linuxExtEnabled == 0)
3984                 ses->capabilities &= (~server->vals->cap_unix);
3985
3986         cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3987                  server->sec_mode, server->capabilities, server->timeAdj);
3988
3989         if (server->ops->sess_setup)
3990                 rc = server->ops->sess_setup(xid, ses, nls_info);
3991
3992         if (rc)
3993                 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3994
3995         return rc;
3996 }
3997
3998 static int
3999 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4000 {
4001         vol->sectype = ses->sectype;
4002
4003         /* krb5 is special, since we don't need username or pw */
4004         if (vol->sectype == Kerberos)
4005                 return 0;
4006
4007         return cifs_set_cifscreds(vol, ses);
4008 }
4009
4010 static struct cifs_tcon *
4011 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4012 {
4013         int rc;
4014         struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4015         struct cifs_ses *ses;
4016         struct cifs_tcon *tcon = NULL;
4017         struct smb_vol *vol_info;
4018
4019         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4020         if (vol_info == NULL)
4021                 return ERR_PTR(-ENOMEM);
4022
4023         vol_info->local_nls = cifs_sb->local_nls;
4024         vol_info->linux_uid = fsuid;
4025         vol_info->cred_uid = fsuid;
4026         vol_info->UNC = master_tcon->treeName;
4027         vol_info->retry = master_tcon->retry;
4028         vol_info->nocase = master_tcon->nocase;
4029         vol_info->local_lease = master_tcon->local_lease;
4030         vol_info->no_linux_ext = !master_tcon->unix_ext;
4031         vol_info->sectype = master_tcon->ses->sectype;
4032         vol_info->sign = master_tcon->ses->sign;
4033
4034         rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4035         if (rc) {
4036                 tcon = ERR_PTR(rc);
4037                 goto out;
4038         }
4039
4040         /* get a reference for the same TCP session */
4041         spin_lock(&cifs_tcp_ses_lock);
4042         ++master_tcon->ses->server->srv_count;
4043         spin_unlock(&cifs_tcp_ses_lock);
4044
4045         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4046         if (IS_ERR(ses)) {
4047                 tcon = (struct cifs_tcon *)ses;
4048                 cifs_put_tcp_session(master_tcon->ses->server);
4049                 goto out;
4050         }
4051
4052         tcon = cifs_get_tcon(ses, vol_info);
4053         if (IS_ERR(tcon)) {
4054                 cifs_put_smb_ses(ses);
4055                 goto out;
4056         }
4057
4058         if (cap_unix(ses))
4059                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4060 out:
4061         kfree(vol_info->username);
4062         kfree(vol_info->password);
4063         kfree(vol_info);
4064
4065         return tcon;
4066 }
4067
4068 struct cifs_tcon *
4069 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4070 {
4071         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4072 }
4073
4074 /* find and return a tlink with given uid */
4075 static struct tcon_link *
4076 tlink_rb_search(struct rb_root *root, kuid_t uid)
4077 {
4078         struct rb_node *node = root->rb_node;
4079         struct tcon_link *tlink;
4080
4081         while (node) {
4082                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4083
4084                 if (uid_gt(tlink->tl_uid, uid))
4085                         node = node->rb_left;
4086                 else if (uid_lt(tlink->tl_uid, uid))
4087                         node = node->rb_right;
4088                 else
4089                         return tlink;
4090         }
4091         return NULL;
4092 }
4093
4094 /* insert a tcon_link into the tree */
4095 static void
4096 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4097 {
4098         struct rb_node **new = &(root->rb_node), *parent = NULL;
4099         struct tcon_link *tlink;
4100
4101         while (*new) {
4102                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4103                 parent = *new;
4104
4105                 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4106                         new = &((*new)->rb_left);
4107                 else
4108                         new = &((*new)->rb_right);
4109         }
4110
4111         rb_link_node(&new_tlink->tl_rbnode, parent, new);
4112         rb_insert_color(&new_tlink->tl_rbnode, root);
4113 }
4114
4115 /*
4116  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4117  * current task.
4118  *
4119  * If the superblock doesn't refer to a multiuser mount, then just return
4120  * the master tcon for the mount.
4121  *
4122  * First, search the rbtree for an existing tcon for this fsuid. If one
4123  * exists, then check to see if it's pending construction. If it is then wait
4124  * for construction to complete. Once it's no longer pending, check to see if
4125  * it failed and either return an error or retry construction, depending on
4126  * the timeout.
4127  *
4128  * If one doesn't exist then insert a new tcon_link struct into the tree and
4129  * try to construct a new one.
4130  */
4131 struct tcon_link *
4132 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4133 {
4134         int ret;
4135         kuid_t fsuid = current_fsuid();
4136         struct tcon_link *tlink, *newtlink;
4137
4138         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4139                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4140
4141         spin_lock(&cifs_sb->tlink_tree_lock);
4142         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4143         if (tlink)
4144                 cifs_get_tlink(tlink);
4145         spin_unlock(&cifs_sb->tlink_tree_lock);
4146
4147         if (tlink == NULL) {
4148                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4149                 if (newtlink == NULL)
4150                         return ERR_PTR(-ENOMEM);
4151                 newtlink->tl_uid = fsuid;
4152                 newtlink->tl_tcon = ERR_PTR(-EACCES);
4153                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4154                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4155                 cifs_get_tlink(newtlink);
4156
4157                 spin_lock(&cifs_sb->tlink_tree_lock);
4158                 /* was one inserted after previous search? */
4159                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4160                 if (tlink) {
4161                         cifs_get_tlink(tlink);
4162                         spin_unlock(&cifs_sb->tlink_tree_lock);
4163                         kfree(newtlink);
4164                         goto wait_for_construction;
4165                 }
4166                 tlink = newtlink;
4167                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4168                 spin_unlock(&cifs_sb->tlink_tree_lock);
4169         } else {
4170 wait_for_construction:
4171                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4172                                   TASK_INTERRUPTIBLE);
4173                 if (ret) {
4174                         cifs_put_tlink(tlink);
4175                         return ERR_PTR(-ERESTARTSYS);
4176                 }
4177
4178                 /* if it's good, return it */
4179                 if (!IS_ERR(tlink->tl_tcon))
4180                         return tlink;
4181
4182                 /* return error if we tried this already recently */
4183                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4184                         cifs_put_tlink(tlink);
4185                         return ERR_PTR(-EACCES);
4186                 }
4187
4188                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4189                         goto wait_for_construction;
4190         }
4191
4192         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4193         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4194         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4195
4196         if (IS_ERR(tlink->tl_tcon)) {
4197                 cifs_put_tlink(tlink);
4198                 return ERR_PTR(-EACCES);
4199         }
4200
4201         return tlink;
4202 }
4203
4204 /*
4205  * periodic workqueue job that scans tcon_tree for a superblock and closes
4206  * out tcons.
4207  */
4208 static void
4209 cifs_prune_tlinks(struct work_struct *work)
4210 {
4211         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4212                                                     prune_tlinks.work);
4213         struct rb_root *root = &cifs_sb->tlink_tree;
4214         struct rb_node *node = rb_first(root);
4215         struct rb_node *tmp;
4216         struct tcon_link *tlink;
4217
4218         /*
4219          * Because we drop the spinlock in the loop in order to put the tlink
4220          * it's not guarded against removal of links from the tree. The only
4221          * places that remove entries from the tree are this function and
4222          * umounts. Because this function is non-reentrant and is canceled
4223          * before umount can proceed, this is safe.
4224          */
4225         spin_lock(&cifs_sb->tlink_tree_lock);
4226         node = rb_first(root);
4227         while (node != NULL) {
4228                 tmp = node;
4229                 node = rb_next(tmp);
4230                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4231
4232                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4233                     atomic_read(&tlink->tl_count) != 0 ||
4234                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4235                         continue;
4236
4237                 cifs_get_tlink(tlink);
4238                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4239                 rb_erase(tmp, root);
4240
4241                 spin_unlock(&cifs_sb->tlink_tree_lock);
4242                 cifs_put_tlink(tlink);
4243                 spin_lock(&cifs_sb->tlink_tree_lock);
4244         }
4245         spin_unlock(&cifs_sb->tlink_tree_lock);
4246
4247         queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4248                                 TLINK_IDLE_EXPIRE);
4249 }