fs/cifs/connect.c

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