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