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