fs/cifs/connect.c

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