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